Why doesn’t C++ move construct rvalue references by default? [duplicate]

by

with your design:

void doWork(Widget && param)
{
    Widget store1 = param;     // automatically move param
    Widget store2 = param;     // boom

    Widget store_last = param; // boom    
}

with current design:

void doWork(Widget && param)
{
    Widget store1 = param;                // ok, copy
    Widget store2 = param;                // ok, copy

    Widget store_last = std::move(param); // ok, param is moved at its last use
}

So the moral here is that even if you have an rvalue reference you have a name for it which means you can use it multiple times. As such you can’t automatically move it because you could need it for a later use.

Now let’s say you want to re-design the language so that the last use is automatically treated as an rvalue.

This can be easily done in the above example:

void doWork(Widget && param)
{
    Widget store1 = param;     // `param` treated as lvalue here, copy
    Widget store2 = param;     // `param` treated as lvalue here, copy

    Widget store_last = param; // `param` treated as rvalue here, move    
}

Let’s ignore the inconsistency of how param is treated (which in itself is a problem).

Now think what use of param is the last use:

void doWork(Widget && param)
{  
    Widget store2 = param;        // this can be last use or not

    while (some_condition())
    {
         Widget store1 = param;   // this can be both last use and not
    }
}

The language simply cannot be designed this way.

More Related Contents:

  1. Should a move constructor take a const or non-const rvalue reference?
  2. C++11 rvalue reference calling copy constructor too
  3. What are the main purposes of using std::forward and which problems it solves?
  4. Conditions for automatic generation of default/copy/move ctor and copy/move assignment operator?
  5. What does T&& (double ampersand) mean in C++11?
  6. What is std::move(), and when should it be used?
  7. Move capture in lambda
  8. Why is `std::move` named `std::move`?
  9. Syntax for universal references
  10. Why are rvalues references variables not rvalue?
  11. Is the pass-by-value-and-then-move construct a bad idiom?
  12. What’s a use case for overloading member functions on reference qualifiers?
  13. non-class rvalues always have cv-unqualified types
  14. In C++, what categories (lvalue, rvalue, xvalue, etc.) can expressions that produce temporaries of class type fall into?
  15. Why is this code trying to call the copy constructor?
  16. Are move constructors produced automatically?
  17. Is it possible to std::move objects out of functions? (C++11)
  18. Why do some people use swap for move assignments?
  19. Can I typically/always use std::forward instead of std::move?
  20. Can compiler generate std::move for a last use of lvalue automatically?
  21. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  22. How to make template rvalue reference parameter ONLY bind to rvalue reference?
  23. Passing rvalues through std::bind
  24. Understanding rvalue references
  25. problems with Move constructor and Move overloaded assignment operator?
  26. How does std::forward receive the correct argument?
  27. What is std::move(), and when should it be used and does it actually move anything?
  28. Is there a reference_wrapper for rvalue references?
  29. C++ forwarding reference and r-value reference
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment