copy vs std::move for ints

by

In this example, there is no difference. We will end up with 3 ints with value 100. There could definitely be a difference with different types though. For instance, let’s consider something like vector<int>:

std::vector<int> a = {1, 2, 3, 4, 5}; // a has size 5
auto a_copy = a;                      // copy a. now we have two vectors of size 5
auto a_move = std::move(a);           // *move* a into a_move

The last variable, a_move, takes ownership of a‘s internal pointers. So what we end up with is a_move is a vector of size 5, but a is now empty. The move is much more efficient than a copy (imagine if it was a vector of 1000 strings instead – a_copy would involve allocating a 1000-string buffer and copying 1000 strings, but a_move just assigns a couple pointers).

For some other types, one might be invalid:

std::unique_ptr<int> a{new int 42};
auto a_copy = a;            // error
auto a_move = std::move(a); // OK, now a_move owns 42, but a points to nothing

For many types, there’s no difference though:

std::array<int, 100> a;
auto a_copy = a;            // copy 100 ints
auto a_move = std::move(a); // also copy 100 ints, no special move ctor

More generally:

T a;
auto a_copy = a;            // calls T(const T& ), the copy constructor
auto a_move = std::move(a); // calls T(T&& ), the move constructor

More Related Contents:

  1. What is move semantics?
  2. How to enforce move semantics when a vector grows?
  3. What can I do with a moved-from object?
  4. When should std::move be used on a function return value? [duplicate]
  5. Reusing a moved container?
  6. Why no default move-assignment/move-constructor?
  7. Move assignment operator and `if (this != &rhs)`
  8. What are the rules for automatic generation of move operations?
  9. What does the standard library guarantee about self move assignment?
  10. Is a moved-from vector always empty?
  11. Why does std::move prevent RVO (return value optimization)?
  12. How does std::move() transfer values into RValues?
  13. How to actually implement the rule of five?
  14. Does moving leave the object in a usable state?
  15. Why do we copy then move?
  16. Why do some people use swap for move assignments?
  17. Initializer-list-constructing a vector of noncopyable (but movable) objects
  18. Is a `=default` move constructor equivalent to a member-wise move constructor?
  19. Should I delete the move constructor and the move assignment of a smart pointer?
  20. Is an object guaranteed to be moved when it is returned?
  21. Why do you use std::move when you have && in C++11? [duplicate]
  22. Is there any case where a return of a RValue Reference (&&) is useful?
  23. Move or Named Return Value Optimization (NRVO)?
  24. C++11 virtual destructors and auto generation of move special functions
  25. When is explicit move needed for a return statement?
  26. Move out element of std priority_queue in C++11
  27. Why would I std::move an std::shared_ptr?
  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. What is use of the ref-qualifier `const &&`?

Leave a Comment