How does std::move() transfer values into RValues?

by

We start with the move function (which I cleaned up a little bit):

template <typename T>
typename remove_reference<T>::type&& move(T&& arg)
{
  return static_cast<typename remove_reference<T>::type&&>(arg);
}

Let’s start with the easier part – that is, when the function is called with rvalue:

Object a = std::move(Object());
// Object() is temporary, which is prvalue

and our move template gets instantiated as follows:

// move with [T = Object]:
remove_reference<Object>::type&& move(Object&& arg)
{
  return static_cast<remove_reference<Object>::type&&>(arg);
}

Since remove_reference converts T& to T or T&& to T, and Object is not reference, our final function is:

Object&& move(Object&& arg)
{
  return static_cast<Object&&>(arg);
}

Now, you might wonder: do we even need the cast? The answer is: yes, we do. The reason is simple; named rvalue reference is treated as lvalue (and implicit conversion from lvalue to rvalue reference is forbidden by standard).

Here’s what happens when we call move with lvalue:

Object a; // a is lvalue
Object b = std::move(a);

and corresponding move instantiation:

// move with [T = Object&]
remove_reference<Object&>::type&& move(Object& && arg)
{
  return static_cast<remove_reference<Object&>::type&&>(arg);
}

Again, remove_reference converts Object& to Object and we get:

Object&& move(Object& && arg)
{
  return static_cast<Object&&>(arg);
}

Now we get to the tricky part: what does Object& && even mean and how can it bind to lvalue?

To allow perfect forwarding, C++11 standard provides special rules for reference collapsing, which are as follows:

Object &  &  = Object &
Object &  && = Object &
Object && &  = Object &
Object && && = Object &&

As you can see, under these rules Object& && actually means Object&, which is plain lvalue reference that allows binding lvalues.

Final function is thus:

Object&& move(Object& arg)
{
  return static_cast<Object&&>(arg);
}

which is not unlike the previous instantiation with rvalue – they both cast its argument to rvalue reference and then return it. The difference is that first instantiation can be used with rvalues only, while the second one works with lvalues.

To explain why do we need remove_reference a bit more, let’s try this function

template <typename T>
T&& wanna_be_move(T&& arg)
{
  return static_cast<T&&>(arg);
}

and instantiate it with lvalue.

// wanna_be_move [with T = Object&]
Object& && wanna_be_move(Object& && arg)
{
  return static_cast<Object& &&>(arg);
}

Applying the reference collapsing rules mentioned above, you can see we get function that is unusable as move (to put it simply, you call it with lvalue, you get lvalue back). If anything, this function is the identity function.

Object& wanna_be_move(Object& arg)
{
  return static_cast<Object&>(arg);
}

More Related Contents:

  1. What is “rvalue reference for *this”?
  2. C++11 rvalues and move semantics confusion (return statement)
  3. initializer_list and move semantics
  4. When should std::move be used on a function return value? [duplicate]
  5. What is the advantage of using forwarding references in range-based for loops?
  6. Move assignment operator and `if (this != &rhs)`
  7. Why is `std::move` named `std::move`?
  8. What does the standard library guarantee about self move assignment?
  9. Is a moved-from vector always empty?
  10. Why does std::move prevent RVO (return value optimization)?
  11. How to actually implement the rule of five?
  12. Does moving leave the object in a usable state?
  13. Why do we copy then move?
  14. Initializer-list-constructing a vector of noncopyable (but movable) objects
  15. Should I delete the move constructor and the move assignment of a smart pointer?
  16. copy vs std::move for ints
  17. Is an object guaranteed to be moved when it is returned?
  18. Why do you use std::move when you have && in C++11? [duplicate]
  19. Do built-in types have move semantics?
  20. Is there any case where a return of a RValue Reference (&&) is useful?
  21. When to make a type non-movable in C++11?
  22. Is std::array movable?
  23. C++11 virtual destructors and auto generation of move special functions
  24. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  25. When is explicit move needed for a return statement?
  26. Move out element of std priority_queue in C++11
  27. Why would I std::move an std::shared_ptr?
  28. C++: std::move with rvalue reference is not moving contents
  29. What is std::move(), and when should it be used and does it actually move anything?
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment