Is it possible to std::move objects out of functions? (C++11)

by

Given this example,

X foo ()
{
  X x;    
  return x;
}

the following behavior is guaranteed:

• If X has an accessible copy or move constructor, the compiler may
choose to elide the copy. This is the so-called (named) return value
optimization ((N)RVO), which was specified even before C++11 and is
supported by most compilers.
• Otherwise, if X has a move constructor, x is moved.
• Otherwise, if X has a copy constructor, x is copied.
• Otherwise, a compile-time error is emitted.

Note also that returning an rvalue reference is an error if the returned object is a local nonstatic object:

X&& foo ()
{
  X x;
  return x; // ERROR: returns reference to nonexistent object
}

An rvalue reference is a reference, and returning it while referring to a local object means that you
return a reference to an object that doesn’t exist any more. Whether std::move() is used doesn’t
matter.

std::move() doesn’t really move object; it only turns lvalues into rvalues.

More Related Contents:

  1. C++11 rvalues and move semantics confusion (return statement)
  2. Why is `std::move` named `std::move`?
  3. Is the pass-by-value-and-then-move construct a bad idiom?
  4. How to actually implement the rule of five?
  5. Why do some people use swap for move assignments?
  6. Can I typically/always use std::forward instead of std::move?
  7. Is there any case where a return of a RValue Reference (&&) is useful?
  8. What is use of the ref-qualifier `const &&`?
  9. Declaring lambda with int type not working [closed]
  10. Rvalue Reference is Treated as an Lvalue?
  11. Is returning by rvalue reference more efficient?
  12. When should std::move be used on a function return value? [duplicate]
  13. C++11 make_pair with specified template parameters doesn’t compile
  14. Move assignment operator and `if (this != &rhs)`
  15. Overload resolution between object, rvalue reference, const reference
  16. What does the standard library guarantee about self move assignment?
  17. Is a moved-from vector always empty?
  18. Why do we copy then move?
  19. Initializer-list-constructing a vector of noncopyable (but movable) objects
  20. Is an object guaranteed to be moved when it is returned?
  21. Why do you use std::move when you have && in C++11? [duplicate]
  22. Should a move constructor take a const or non-const rvalue reference?
  23. C++11 rvalue reference calling copy constructor too
  24. C++11 virtual destructors and auto generation of move special functions
  25. When is explicit move needed for a return statement?
  26. Move out element of std priority_queue in C++11
  27. Move semantics == custom swap function obsolete?
  28. Is there a reference_wrapper for rvalue references?
  29. Move constructor on derived object
  30. Why can’t C++11 move a noncopyable functor to a std::function?

Leave a Comment