Why do I have to call move on an rvalue reference?

by

As skypjack correctly comments, accessing an object through its name always results in an lvalue reference.

This is a safety feature and if you think it through you will realise that you are glad of it.

As you know, std::move simply casts an l-value reference to an r-value reference. If we use the returned r-value reference immediately (i.e. un-named) then it remains an r-value reference.

This means that the use of the r-value can only be at the point in the code where move(x) is mentioned. From a code-reader’s perspective, it’s now easy to see where x’s state became undefined.

so:

 1: auto x = make_x();
 2: auto&& r = std::move(x);
 3: // lots of other stuff
35: // ...
54: // ...
55: take_my_x(r);

does not work. If it did, someone maintaining the code would have a hard time seeing (and remembering) that x (defined on line 1) enters an undefined state on line 55 through a reference taken on line 2.

This is a good deal more explicit:

 1: auto x = make_x();
 2: //
 3: // lots of other stuff
35: // ...
54: // ...
55: take_my_x(std::move(x));

More Related Contents:

  1. What is “rvalue reference for *this”?
  2. push_back vs emplace_back
  3. C++11 rvalues and move semantics confusion (return statement)
  4. What is std::move(), and when should it be used?
  5. Can I list-initialize a vector of move-only type?
  6. initializer_list and move semantics
  7. When should std::move be used on a function return value? [duplicate]
  8. What is the advantage of using forwarding references in range-based for loops?
  9. How do I use a custom deleter with a std::unique_ptr member?
  10. What constitutes a valid state for a “moved from” object in C++11?
  11. Why is `std::move` named `std::move`?
  12. What does the standard library guarantee about self move assignment?
  13. C++11 move constructor not called, default constructor preferred
  14. Is the pass-by-value-and-then-move construct a bad idiom?
  15. Move-only version of std::function
  16. Is it possible to std::move objects out of functions? (C++11)
  17. Why do some people use swap for move assignments?
  18. Non-copyable elements in vector
  19. Can I typically/always use std::forward instead of std::move?
  20. copy vs std::move for ints
  21. Do built-in types have move semantics?
  22. When to make a type non-movable in C++11?
  23. Is std::array movable?
  24. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  25. Why copy constructor is called in std::vector’s initializer list?
  26. Move out element of std priority_queue in C++11
  27. Why would I std::move an std::shared_ptr?
  28. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  29. Move semantics == custom swap function obsolete?
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment