Why do you use std::move when you have && in C++11? [duplicate]

by

First, there’s probably a misconception in the question I’ll address:
Whenever you see T&& t in code (And T is an actual type, not a template type), keep in mind the value category of t is an lvalue(reference), not an rvalue(temporary) anymore. It’s very confusing. The T&& merely means that t is constructed from an object that was an rvalue 1, but t itself is an lvalue, not an rvalue. If it has a name (in this case, t) then it’s an lvalue and won’t automatically move, but if it has no name (the result of 3+4) then it is an rvalue and will automatically move into it’s result if it can. The type (in this case T&&) has almost nothing to do with the value category of the variable (in this case, an lvalue).

That being said, if you have T&& t written in your code, that means you have a reference to a variable that was a temporary, and it is ok to destroy if you want to. If you need to access the variable multiple times, you do not want to std::move from it, or else it would lose it’s value. But the last time you acccess t it is safe to std::move it’s value to another T if you wish. (And 95% of the time, that’s what you want to do). All of this also applies to auto&& variables.

1. if T is a template type, T&& is a forwarding reference instead, in which case you use std::forward<T>(t) instead of std::move(t) the last time. See this question.

More Related Contents:

  1. What is move semantics?
  2. push_back vs emplace_back
  3. How to enforce move semantics when a vector grows?
  4. What is std::move(), and when should it be used?
  5. What can I do with a moved-from object?
  6. Can I list-initialize a vector of move-only type?
  7. How do I use a custom deleter with a std::unique_ptr member?
  8. Reusing a moved container?
  9. Why no default move-assignment/move-constructor?
  10. What constitutes a valid state for a “moved from” object in C++11?
  11. Move assignment operator and `if (this != &rhs)`
  12. What are the rules for automatic generation of move operations?
  13. Why is `std::move` named `std::move`?
  14. C++11 move constructor not called, default constructor preferred
  15. Why does std::move prevent RVO (return value optimization)?
  16. Is the pass-by-value-and-then-move construct a bad idiom?
  17. Move-only version of std::function
  18. How does std::move() transfer values into RValues?
  19. Does moving leave the object in a usable state?
  20. Is it possible to std::move objects out of functions? (C++11)
  21. Why do some people use swap for move assignments?
  22. Non-copyable elements in vector
  23. Initializer-list-constructing a vector of noncopyable (but movable) objects
  24. Can I typically/always use std::forward instead of std::move?
  25. Is a `=default` move constructor equivalent to a member-wise move constructor?
  26. Is an object guaranteed to be moved when it is returned?
  27. Move or Named Return Value Optimization (NRVO)?
  28. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  29. Move semantics == custom swap function obsolete?
  30. Move constructor on derived object

Leave a Comment