The ::value_type of the std::map/std::unordered_map containers is std::pair<const Key, T>.
Currently a lot of loops drop the const from the iterator which forces the compiler to create a copy, this should be avoided by using the auto keyword.
A better explanation can be found in Meyer’s Effective Modern C++.
https://books.google.de/books?id=rjhIBQAAQBAJ&lpg=PA41&ots=FmZL15vynY&pg=PA41#v=onepage&q&f=false
Currently a lot of loops drop the const from the iterator which forces the compiler to create a copy, this should be avoided by using the auto keyword.
I don’t understand this rationale for using auto. Why doesn’t adding const to the iterator have the same effect of avoiding copies?
I don’t understand this rationale for using auto. Why doesn’t adding const to the iterator have the same effect of avoiding copies?
If you take a const reference to a type that requires an implicit conversion it will make a copy. Example where loop items are copied:
0vector<pair<int, int>> v;
1...
2for (const pair<short, short>& p : v);
Using auto would avoid the copy. You could also drop const to trigger a compiler error if the copies are unintended.
0#include <iostream>
1
2struct Foo {
3 Foo () { std::cout << " Foo()" << std::endl; }
4 Foo (const Foo& z) { std::cout << " Foo(Foo)" << std::endl; }
5 Foo (const Foo&& z) { std::cout << " Foo(Foo&&)" << std::endl; }
6};
7using FooInt = std::pair<const Foo, int>;
8
9int main () {
10 std::cout << "Init" << std::endl;
11 const auto bar = {
12 FooInt{ Foo(), 0 },
13 { Foo(), 1 },
14 { Foo(), 2 }
15 };
16
17 std::cout << "FooInt : bar" << std::endl;
18 for (FooInt x : bar) {}
19
20 std::cout << "const FooInt& : bar" << std::endl;
21 for (const FooInt& x : bar) {}
22
23 std::cout << "const std::pair<Foo, int>& : bar" << std::endl;
24 for (const std::pair<Foo, int>& x : bar) {}
25
26 std::cout << "const std::pair<const Foo, int>& : bar" << std::endl;
27 for (const std::pair<const Foo, int>& x : bar) {}
28
29 std::cout << "auto : bar" << std::endl;
30 for (auto x : bar) {}
31
32 std::cout << "auto& : bar" << std::endl;
33 for (auto& x : bar) {}
34
35 std::cout << "const auto& : bar" << std::endl;
36 for (const auto& x : bar) {}
37
38 return 0;
39}
0$ g++ foo.cpp && ./a.out
1<snip>
2FooInt : bar
3 Foo(Foo)
4 Foo(Foo)
5 Foo(Foo)
6const FooInt& : bar
7const std::pair<Foo, int>& : bar
8 Foo(Foo)
9 Foo(Foo)
10 Foo(Foo)
11const std::pair<const Foo, int>& : bar
12auto : bar
13 Foo(Foo)
14 Foo(Foo)
15 Foo(Foo)
16auto& : bar
17const auto& : bar
Why doesn’t adding const to the iterator have the same effect of avoiding copies?
tl;dr it does have the same effect. AFAIK.
Although personally I think auto helps prevent these nits, you weren’t wrong in your assumption.
edit: wait, if you meant const on the std::pair, not the Key, see above.
The ::value_type of the std::map/std::unordered_map containers is
std::pair<const Key, T>.
Currently a lot of loops drop the const from the iterator which forces
the compiler to create a copy, this should be avoided by using the auto
keyword.
A better explanation can be found in Meyer's Effective Modern C++.
https://books.google.de/books?id=rjhIBQAAQBAJ&lpg=PA41&ots=FmZL15vynY&pg=PA41#v=onepage&q&f=false
