Do built-in types have move semantics?

by

And so, is the one shown by the example a well-defined behavior?

Yes, the behaviour shown in the example is the only behaviour allowed by the standard. That is because std::move doesn’t move. The things that move are move constructors and move assignment operators.

All std::move does is change an lvalue into an xvalue, so that it can bind to rvalue references. It does not invoke any constructor or anything else. Changing the value category happens at the type level. Nothing happens at runtime.

Rvalue references are still references: they refer to the original object. The function increments the original integer through the reference given.

If a function takes an argument by reference, no copies nor moves happen: the original object is bound to the reference.

If a function takes an argument by value, then we might have a move.

However, fundamental types don’t have move constructors. Moves degrade to copies in that case.

More Related Contents:

  1. What is “rvalue reference for *this”?
  2. How to enforce move semantics when a vector grows?
  3. C++11 rvalues and move semantics confusion (return statement)
  4. initializer_list and move semantics
  5. When should std::move be used on a function return value? [duplicate]
  6. What is the advantage of using forwarding references in range-based for loops?
  7. Reusing a moved container?
  8. Move assignment operator and `if (this != &rhs)`
  9. Why is `std::move` named `std::move`?
  10. What does the standard library guarantee about self move assignment?
  11. Is a moved-from vector always empty?
  12. How to actually implement the rule of five?
  13. Does moving leave the object in a usable state?
  14. Why do we copy then move?
  15. Initializer-list-constructing a vector of noncopyable (but movable) objects
  16. Should I delete the move constructor and the move assignment of a smart pointer?
  17. copy vs std::move for ints
  18. Is an object guaranteed to be moved when it is returned?
  19. Why do you use std::move when you have && in C++11? [duplicate]
  20. Is there any case where a return of a RValue Reference (&&) is useful?
  21. When to make a type non-movable in C++11?
  22. Is std::array movable?
  23. C++11 virtual destructors and auto generation of move special functions
  24. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  25. When is explicit move needed for a return statement?
  26. Move out element of std priority_queue in C++11
  27. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  28. C++: std::move with rvalue reference is not moving contents
  29. What is std::move(), and when should it be used and does it actually move anything?
  30. Move constructor on derived object

Leave a Comment