Concise explanation of reference collapsing rules requested: (1) A& & -> A& , (2) A& && -> A& , (3) A&& & -> A& , and (4) A&& && -> A&&

by

The reference collapsing rules (save for A& & -> A&, which is C++98/03) exist for one reason: to allow perfect forwarding to work.

“Perfect” forwarding means to effectively forward parameters as if the user had called the function directly (minus elision, which is broken by forwarding). There are three kinds of values the user could pass: lvalues, xvalues, and prvalues, and there are three ways that the receiving location can take a value: by value, by (possibly const) lvalue reference, and by (possibly const) rvalue reference.

Consider this function:

template<class T>
void Fwd(T &&v) { Call(std::forward<T>(v)); }

By value

If Call takes its parameter by value, then a copy/move must happen into that parameter. Which one depends on what the incoming value is. If the incoming value is an lvalue, then it must copy the lvalue. If the incoming value is an rvalue (which collectively are xvalues and prvalues), then it must move from it.

If you call Fwd with an lvalue, C++’s type-deduction rules mean that T will be deduced as Type&, where Type is the type of the lvalue. Obviously if the lvalue is const, it will be deduced as const Type&. The reference collapsing rules mean that Type & && becomes Type & for v, an lvalue reference. Which is exactly what we need to call Call. Calling it with an lvalue reference will force a copy, exactly as if we had called it directly.

If you call Fwd with an rvalue (ie: a Type temporary expression or certain Type&& expressions), then T will be deduced as Type. The reference collapsing rules give us Type &&, which provokes a move/copy, which is almost exactly as if we had called it directly (minus elision).

By lvalue reference

If Call takes its value by lvalue reference, then it should only be callable when the user uses lvalue parameters. If it’s a const-lvalue reference, then it can be callable by anything (lvalue, xvalue, prvalue).

If you call Fwd with an lvalue, we again get Type& as the type of v. This will bind to a non-const lvalue reference. If we call it with a const lvalue, we get const Type&, which will only bind to a const lvalue reference argument in Call.

If you call Fwd with an xvalue, we again get Type&& as the type of v. This will not allow you to call a function that takes a non-const lvalue, as an xvalue cannot bind to a non-const lvalue reference. It can bind to a const lvalue reference, so if Call used a const&, we could call Fwd with an xvalue.

If you call Fwd with a prvalue, we again get Type&&, so everything works as before. You cannot pass a temporary to a function that takes a non-const lvalue, so our forwarding function will likewise choke in the attempt to do so.

By rvalue reference

If Call takes its value by rvalue reference, then it should only be callable when the user uses xvalue or rvalue parameters.

If you call Fwd with an lvalue, we get Type&. This will not bind to an rvalue reference parameter, so a compile error results. A const Type& also won’t bind to an rvalue reference parameter, so it still fails. And this is exactly what would happen if we called Call directly with an lvalue.

If you call Fwd with an xvalue, we get Type&&, which works (cv-qualification still matters of course).

The same goes for using a prvalue.

std::forward

std::forward itself uses reference collapsing rules in a similar way, so as to pass incoming rvalue references as xvalues (function return values that are Type&& are xvalues) and incoming lvalue references as lvalues (returning Type&).

More Related Contents:

  1. What’s the difference between “STL” and “C++ Standard Library”?
  2. std::endl is of unknown type when overloading operator
  3. Writing your own STL Container
  4. Why does the C++ STL not provide any “tree” containers?
  5. Why doesn’t std::queue::pop return value.?
  6. what happens when you modify an element of an std::set?
  7. What’s faster, iterating an STL vector with vector::iterator or with at()?
  8. How to remove all the occurrences of a char in c++ string
  9. Copy map values to vector in STL [duplicate]
  10. std::map, pointer to map key value, is this possible?
  11. Cleaning up an STL list/vector of pointers
  12. Efficiency of the STL priority_queue
  13. Capturing a time in milliseconds
  14. Performance of qsort vs std::sort?
  15. How does C++ STL unordered_map resolve collisions?
  16. How do I erase elements from STL containers?
  17. What happens when you call data() on a std::vector?
  18. Are const_iterators faster?
  19. STL analogue in Fortran
  20. Vector Iterators Incompatible
  21. Why the libc++ std::vector internally keeps three pointers instead of one pointer and two sizes?
  22. Visual c++ “for each” portability
  23. Is stl vector concurrent read thread-safe?
  24. Why can’t I replace std::map with std::unordered_map
  25. Is it more efficient to copy a vector by reserving and copying, or by creating and swapping? [duplicate]
  26. How to increment an iterator by 2?
  27. What’s the time complexity of iterating through a std::set/std::map?
  28. Why isn’t std::array::size static?
  29. How to convert a string of hex values to a string?
  30. Obtain container type from (its) iterator type in C++ (STL)

Leave a Comment