C++11 rvalues and move semantics confusion (return statement)

by

First example

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> &&rval_ref = return_vector();

The first example returns a temporary which is caught by rval_ref. That temporary will have its life extended beyond the rval_ref definition and you can use it as if you had caught it by value. This is very similar to the following:

const std::vector<int>& rval_ref = return_vector();

except that in my rewrite you obviously can’t use rval_ref in a non-const manner.

Second example

std::vector<int>&& return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

In the second example you have created a run time error. rval_ref now holds a reference to the destructed tmp inside the function. With any luck, this code would immediately crash.

Third example

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

Your third example is roughly equivalent to your first. The std::move on tmp is unnecessary and can actually be a performance pessimization as it will inhibit return value optimization.

The best way to code what you’re doing is:

Best practice

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> rval_ref = return_vector();

I.e. just as you would in C++03. tmp is implicitly treated as an rvalue in the return statement. It will either be returned via return-value-optimization (no copy, no move), or if the compiler decides it can not perform RVO, then it will use vector’s move constructor to do the return. Only if RVO is not performed, and if the returned type did not have a move constructor would the copy constructor be used for the return.

More Related Contents:

  1. Why is `std::move` named `std::move`?
  2. What is move semantics?
  3. What are the main purposes of using std::forward and which problems it solves?
  4. What is “rvalue reference for *this”?
  5. What does T&& (double ampersand) mean in C++11?
  6. What is std::move(), and when should it be used?
  7. Is the pass-by-value-and-then-move construct a bad idiom?
  8. How to actually implement the rule of five?
  9. Is it possible to std::move objects out of functions? (C++11)
  10. Why do some people use swap for move assignments?
  11. Can I typically/always use std::forward instead of std::move?
  12. What are the main purposes of std::forward and which problems does it solve?
  13. Is there any case where a return of a RValue Reference (&&) is useful?
  14. When to make a type non-movable in C++11?
  15. What is std::move(), and when should it be used and does it actually move anything?
  16. What is use of the ref-qualifier `const &&`?
  17. How to enforce move semantics when a vector grows?
  18. What can I do with a moved-from object?
  19. Why no default move-assignment/move-constructor?
  20. What constitutes a valid state for a “moved from” object in C++11?
  21. What are the rules for automatic generation of move operations?
  22. How does std::move() transfer values into RValues?
  23. Is a `=default` move constructor equivalent to a member-wise move constructor?
  24. Passing rvalues through std::bind
  25. When do extra parentheses have an effect, other than on operator precedence?
  26. C++11 rvalue reference calling copy constructor too
  27. Move or Named Return Value Optimization (NRVO)?
  28. problems with Move constructor and Move overloaded assignment operator?
  29. Is there a reference_wrapper for rvalue references?
  30. Move constructor on derived object

Leave a Comment