Is the pass-by-value-and-then-move construct a bad idiom?

by

Expensive-to-move types are rare in modern C++ usage. If you are concerned about the cost of the move, write both overloads:

void set_a(const A& a) { _a = a; }
void set_a(A&& a) { _a = std::move(a); }

or a perfect-forwarding setter:

template <typename T>
void set_a(T&& a) { _a = std::forward<T>(a); }

that will accept lvalues, rvalues, and anything else implicitly convertible to decltype(_a) without requiring extra copies or moves.

Despite requiring an extra move when setting from an lvalue, the idiom is not bad since (a) the vast majority of types provide constant-time moves and (b) copy-and-swap provides exception safety and near-optimal performance in a single line of code.

More Related Contents:

  1. C++11 rvalues and move semantics confusion (return statement)
  2. Why is `std::move` named `std::move`?
  3. How to actually implement the rule of five?
  4. Is it possible to std::move objects out of functions? (C++11)
  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. Rvalue Reference is Treated as an Lvalue?
  10. Is returning by rvalue reference more efficient?
  11. When should std::move be used on a function return value? [duplicate]
  12. C++11 make_pair with specified template parameters doesn’t compile
  13. Overload resolution between object, rvalue reference, const reference
  14. What does the standard library guarantee about self move assignment?
  15. Is a moved-from vector always empty?
  16. Why does std::move prevent RVO (return value optimization)?
  17. How does std::move() transfer values into RValues?
  18. Does moving leave the object in a usable state?
  19. Why do we copy then move?
  20. Initializer-list-constructing a vector of noncopyable (but movable) objects
  21. Is a `=default` move constructor equivalent to a member-wise move constructor?
  22. Is an object guaranteed to be moved when it is returned?
  23. Why do you use std::move when you have && in C++11? [duplicate]
  24. Should a move constructor take a const or non-const rvalue reference?
  25. C++11 virtual destructors and auto generation of move special functions
  26. When is explicit move needed for a return statement?
  27. Move out element of std priority_queue in C++11
  28. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  29. Overloading on R-value references and code duplication
  30. Move semantics == custom swap function obsolete?

Leave a Comment