309

Reading some examples of range based loops they suggest two main ways 1, 2, 3, 4

std::vector<MyClass> vec; for (auto &x : vec) { // x is a reference to an item of vec // We can change vec's items by changing x }

or

for (auto x : vec) { // Value of x is copied from an item of vec // We can not change vec's items by changing x }

Well.

When we don't need changing vec items, IMO, Examples suggest to use second version (by value). Why they don't suggest something which const references (At least I have not found any direct suggestion):

for (auto const &x : vec) // <-- see const keyword { // x is a reference to an const item of vec // We can not change vec's items by changing x }

Isn't it better? Doesn't it avoid a redundant copy in each iteration while it's a const?

Improve this question
0

5 Answers 5

Reset to default
560

If you don't want to change the items as well as want to avoid making copies, then auto const & is the correct choice:

for (auto const &x : vec)

Whoever suggests you to use auto & is wrong. Ignore them.

Here is recap:

  • Choose auto x when you want to work with copies.
  • Choose auto &x when you want to work with original items and may modify them.
  • Choose auto const &x when you want to work with original items and will not modify them.
Improve this answer
Sign up to request clarification or add additional context in comments.

13 Comments

Thanks for the great answer. I guess it should also be pointed out that const auto &x is equivalent to your third choice.
@mloskot: It is equivalent. (and what do you mean by "but it's the same syntax"? The syntax is observably different.)
Missing: auto&& when you don't want to make a needless copy, and don't care if you modify it or not, and you want to just work.
Does the reference distinction apply to copies if you are just working with fundamental types like int/double?
@racarate: I cannot comment on the overall speed, and I think nobody can, without profiling it first. Frankly, I wont base my choice on the speed, rather the clarity of the code. If I want immutability, I'd use const for sure. However, whether it would be auto const &, or auto const has little difference. I'd choose auto const & just to be more consistent.
|
41

If you have a std::vector<int> or std::vector<double>, then it's just fine to use auto (with value copy) instead of const auto&, since copying an int or a double is cheap:

for (auto x : vec) ....

But if you have a std::vector<MyClass>, where MyClass has some non-trivial copy semantics (e.g. std::string, some complex custom class, etc.) then I'd suggest using const auto& to avoid deep-copies:

for (const auto & x : vec) ....
Improve this answer

Comments

6

When we don't need changing vec items, Examples suggest to use first version.

Then they give a wrong suggestion.

Why they don't suggest something which const references

Because they give a wrong suggestion :-) What you mention is correct. If you only want to observe an object, there is no need to create a copy, and there is no need to have a non-const reference to it.

EDIT:

I see the references you link all provide examples of iterating over a range of int values or some other fundamental data type. In that case, since copying an int is not expensive, creating a copy is basically equivalent to (if not more efficient than) having an observing const &.

This is, however, not the case in general for user-defined types. UDTs may be expensive to copy, and if you do not have a reason for creating a copy (such as modifying the retrieved object without altering the original one), then it is preferable to use a const &.

Improve this answer

Comments

3

I would consider

for (auto&& o : range_expr) { ...}

or

for (auto&& o : std::as_const(range_expr)) { ...}

it always works.

and beware of possible Temporary range expression pitfalls.

In C++20 you have something like

for (T thing = foo(); auto& x : thing.items()) { /* ... */ }
Improve this answer

5 Comments

Can you add a rationale for preferring auto&& over auto&?
@LyndenShields auto&& can bind to everything. auto& will not bind to rvalue and won't work if range_expression returns rvalues.
are there reasonable/realistic examples where range_expression returns rvalues?
good question. I don't have any example yet.
@LyndenShields views::transform with a value return type seems the most common/likely example. views::iota is another, perhaps more easily understandable example. These return values, not references to any existing objects, so auto & could not bind to them. auto const & would disallow moving from or otherwise modifying. auto would work but is less general, as if it's used in generic code where lvalues may be returned, then it can cause additional copies.
2

I'm going to be contrary here and say there is no need for auto const & in a range based for loop. Tell me if you think the following function is silly (not in its purpose, but in the way it is written):

long long SafePop(std::vector<uint32_t>& v) { auto const& cv = v; long long n = -1; if (!cv.empty()) { n = cv.back(); v.pop_back(); } return n; }

Here, the author has created a const reference to v to use for all operations which do not modify v. This is silly, in my opinion, and the same argument can be made for using auto const & as the variable in a range based for loop instead of just auto &.

Improve this answer

19 Comments

@BenjaminLindley: So I can infer that you would also argue against const_iterator in a for loop? How do you ensure that you don't change the original items from a container when you iterate over it?
@BenjaminLindley: Why would your code not compile without const_iterator? Let me guess, the container which you iterator over, is const. But why is it const to begin with? Somewhere you're using const to ensure what?
Advantage of making objects const is like the advantages of using private/protected in classes. It avoids further mistakes.
@BenjaminLindley: Oh, I overlooked that. Then in this case, the implementation is silly as well. But if that function did not modify v, the implementation would be fine IMO. And if the loop never modifies the objects it iterates through, it seems right to me to have a ref to const. I see your point though. Mine is that the loop represents a code unit pretty much like the function does, and within that unit there is no instruction which needs to modify the value. Therefore, you can "tag" the whole unit as const, as you would do with a const member function.
So you think const & for range-based is silly, because you wrote an irrelevant imaginary example of an imaginary programmer who did something silly with cv-qualification? ...OK then
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.