When is explicit move needed for a return statement?

by

Update:

Explicit move should not be needed in modern compiler versions.

Core DR 1579 changed the rules so that the return value will be treated as an rvalue even when the types are not the same. GCC 5 implements the new rule, for C++11 as well as C++14.

Original answer:

This is not a limitation of unique_ptr, it’s a limitation of the language, the same limitation applies to any return statement that calls a converting constructor taking an rvalue reference:

struct U { };

struct T {
  T(U&&) { }
};

T f() {
  U u;
  return u;  // error, cannot bind lvalue to U&&
}

This will not compile because [class.copy]/32 says:

When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue.

This means that the expression in a return statement can only be treated as an rvalue if it is eligible for copy/move elision (aka NRVO) but that is too restrictive because it means it only applies when the type is exactly the same, even though the variable is always going out of scope so it would be reasonable to always treat is as an rvalue (technically as an xvalue, an expiring value.)

This was recently suggested by Richard Smith (and previously by Xeo) and I think it’s a very good idea.

More Related Contents:

  1. What is move semantics?
  2. How to enforce move semantics when a vector grows?
  3. What is std::move(), and when should it be used?
  4. What can I do with a moved-from object?
  5. Can I list-initialize a vector of move-only type?
  6. How do I use a custom deleter with a std::unique_ptr member?
  7. Reusing a moved container?
  8. Why no default move-assignment/move-constructor?
  9. What constitutes a valid state for a “moved from” object in C++11?
  10. Move assignment operator and `if (this != &rhs)`
  11. What are the rules for automatic generation of move operations?
  12. How to return a std::string.c_str()
  13. Why does std::move prevent RVO (return value optimization)?
  14. Is the pass-by-value-and-then-move construct a bad idiom?
  15. Move-only version of std::function
  16. How does std::move() transfer values into RValues?
  17. Does moving leave the object in a usable state?
  18. Is it possible to std::move objects out of functions? (C++11)
  19. Why do some people use swap for move assignments?
  20. Initializer-list-constructing a vector of noncopyable (but movable) objects
  21. Is a `=default` move constructor equivalent to a member-wise move constructor?
  22. Is an object guaranteed to be moved when it is returned?
  23. lvalue to rvalue implicit conversion
  24. Move or Named Return Value Optimization (NRVO)?
  25. C++11 virtual destructors and auto generation of move special functions
  26. Returning a void?
  27. C++: std::move with rvalue reference is not moving contents
  28. Is it possible to invoke a user-defined conversion function via list-initialization?
  29. What is std::move(), and when should it be used and does it actually move anything?
  30. Move constructor on derived object

Leave a Comment