Can compiler generate std::move for a last use of lvalue automatically?

by

No. Consider:

using X = std::shared_ptr<int>;
void g(X);
void f() {
    X b = std::make_shared<int>();
    int &i = *b;
    g(b);              // last use of 'b'
    i = 5;
}

In general, the compiler cannot assume that altering the semantics of copies, moves and destructors of X will be a legitimate change without performing analysis on all the code surrounding the use of b (i.e., the whole of f, g, and all the types used therein).

Indeed, in some cases whole-program analysis may be necessary:

using X = std::shared_ptr<std::lock_guard<std::mutex>>;
std::mutex i_mutex;
int i;
void g(X);
void f() {
    X b = std::make_shared<std::lock_guard<std::mutex>>(i_mutex);
    g(b);              // last use of 'b'
    i = 5;
}

If b is moved, this introduces a data race against other threads that synchronize access to i using i_mutex.

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. Rvalue Reference is Treated as an Lvalue?
  5. Is returning by rvalue reference more efficient?
  6. Move capture in lambda
  7. C++11 make_pair with specified template parameters doesn’t compile
  8. Do rvalue references to const have any use?
  9. Why is `std::move` named `std::move`?
  10. Overload resolution between object, rvalue reference, const reference
  11. Syntax for universal references
  12. Is the pass-by-value-and-then-move construct a bad idiom?
  13. How to actually implement the rule of five?
  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. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  21. What are the main purposes of std::forward and which problems does it solve?
  22. Is there any case where a return of a RValue Reference (&&) is useful?
  23. Passing rvalues through std::bind
  24. Should a move constructor take a const or non-const rvalue reference?
  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. Overloading on R-value references and code duplication
  29. How does std::forward receive the correct argument?
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment