Avoid temporary copies in C++11 ranged-based for loops. #12169

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:

vector<pair<int, int>> v;
...
for (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.

#include <iostream>

struct Foo {
	Foo () { std::cout << "  Foo()" << std::endl; }
	Foo (const Foo& z) { std::cout << "  Foo(Foo)" << std::endl; }
	Foo (const Foo&& z) { std::cout << "  Foo(Foo&&)" << std::endl; }
};
using FooInt = std::pair<const Foo, int>;

int main () {
	std::cout << "Init" << std::endl;
	const auto bar = {
		FooInt{ Foo(), 0 },
		{ Foo(), 1 },
		{ Foo(), 2 }
	};

	std::cout << "FooInt : bar" << std::endl;
	for (FooInt x : bar) {}

	std::cout << "const FooInt& : bar" << std::endl;
	for (const FooInt& x : bar) {}

	std::cout << "const std::pair<Foo, int>& : bar" << std::endl;
	for (const std::pair<Foo, int>& x : bar) {}

	std::cout << "const std::pair<const Foo, int>& : bar" << std::endl;
	for (const std::pair<const Foo, int>& x : bar) {}

	std::cout << "auto : bar" << std::endl;
	for (auto x : bar) {}

	std::cout << "auto& : bar" << std::endl;
	for (auto& x : bar) {}

	std::cout << "const auto& : bar" << std::endl;
	for (const auto& x : bar) {}

	return 0;
}

$ g++ foo.cpp && ./a.out
<snip>
FooInt : bar
  Foo(Foo)
  Foo(Foo)
  Foo(Foo)
const FooInt& : bar
const std::pair<Foo, int>& : bar
  Foo(Foo)
  Foo(Foo)
  Foo(Foo)
const std::pair<const Foo, int>& : bar
auto : bar
  Foo(Foo)
  Foo(Foo)
  Foo(Foo)
auto& : bar
const 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.

Needs rebase if still relevant

rebased

needs rebase

Would be great to avoid these copies, but IMO there is potential documentation / clarity benefit to being explicit about the pair types. How about changing this to just add const to the key types?

Going to close this as it seems to be inactive, let me know if you want to pick it up again then I'll reopen.

I'll take it.