Is returning by rvalue reference more efficient?

by 
Beta_ab&&
Beta::toAB() const {
    return move(Beta_ab(1, 1));
}

This returns a dangling reference, just like with the lvalue reference case. After the function returns, the temporary object will get destructed. You should return Beta_ab by value, like the following 

Beta_ab
Beta::toAB() const {
    return Beta_ab(1, 1);
}

Now, it’s properly moving a temporary Beta_ab object into the return value of the function. If the compiler can, it will avoid the move altogether, by using RVO (return value optimization). Now, you can do the following

Beta_ab ab = others.toAB();

And it will move construct the temporary into ab, or do RVO to omit doing a move or copy altogether. I recommend you to read BoostCon09 Rvalue References 101 which explains the matter, and how (N)RVO happens to interact with this.

Your case of returning an rvalue reference would be a good idea in other occasions. Imagine you have a getAB() function which you often invoke on a temporary. It’s not optimal to make it return a const lvalue reference for rvalue temporaries. You may implement it like this

struct Beta {
  Beta_ab ab;
  Beta_ab const& getAB() const& { return ab; }
  Beta_ab && getAB() && { return move(ab); }
};

Note that move in this case is not optional, because ab is neither a local automatic nor a temporary rvalue. Now, the ref-qualifier && says that the second function is invoked on rvalue temporaries, making the following move, instead of copy

Beta_ab ab = Beta().getAB();

More Related Contents:

  1. Rule-of-Three becomes Rule-of-Five with C++11? [closed]
  2. What are the main purposes of using std::forward and which problems it solves?
  3. What does T&& (double ampersand) mean in C++11?
  4. C++11 rvalues and move semantics confusion (return statement)
  5. Rvalue Reference is Treated as an Lvalue?
  6. C++11 make_pair with specified template parameters doesn’t compile
  7. Do rvalue references to const have any use?
  8. Why is `std::move` named `std::move`?
  9. Overload resolution between object, rvalue reference, const reference
  10. Syntax for universal references
  11. Is the pass-by-value-and-then-move construct a bad idiom?
  12. How to actually implement the rule of five?
  13. Why user-defined move-constructor disables the implicit copy-constructor?
  14. What’s a use case for overloading member functions on reference qualifiers?
  15. non-class rvalues always have cv-unqualified types
  16. In C++, what categories (lvalue, rvalue, xvalue, etc.) can expressions that produce temporaries of class type fall into?
  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. What are the main purposes of std::forward and which problems does it solve?
  23. Is there any case where a return of a RValue Reference (&&) is useful?
  24. Passing rvalues through std::bind
  25. C++11 rvalue reference calling copy constructor too
  26. Understanding rvalue references
  27. Operator overload which permits capturing with rvalue but not assigning to
  28. How does std::forward receive the correct argument?
  29. What is use of the ref-qualifier `const &&`?
  30. Is there a reference_wrapper for rvalue references?

Leave a Comment