What can I do with a moved-from object?

by

17.6.5.15 [lib.types.movedfrom]

Objects of types defined in the C++ standard library may be moved from
(12.8). Move operations may be explicitly specified or implicitly
generated. Unless otherwise specified, such moved-from objects shall
be placed in a valid but unspecified state.

When an object is in an unspecified state, you can perform any operation on the object which has no preconditions. If there is an operation with preconditions you wish to perform, you can not directly perform that operation because you do not know if the unspecified-state of the object satisfies the preconditions.

Examples of operations that generally do not have preconditions:

  • destruction
  • assignment
  • const observers such as get, empty, size

Examples of operations that generally do have preconditions:

  • dereference
  • pop_back

This answer now appears in video format here: http://www.youtube.com/watch?v=vLinb2fgkHk&t=47m10s

More Related Contents:

  1. Move semantics == custom swap function obsolete?
  2. What is “rvalue reference for *this”?
  3. push_back vs emplace_back
  4. C++11 rvalues and move semantics confusion (return statement)
  5. What is std::move(), and when should it be used?
  6. Can I list-initialize a vector of move-only type?
  7. initializer_list and move semantics
  8. When should std::move be used on a function return value? [duplicate]
  9. What is the advantage of using forwarding references in range-based for loops?
  10. How do I use a custom deleter with a std::unique_ptr member?
  11. Why is `std::move` named `std::move`?
  12. What does the standard library guarantee about self move assignment?
  13. C++11 move constructor not called, default constructor preferred
  14. Is a moved-from vector always empty?
  15. Move-only version of std::function
  16. How to actually implement the rule of five?
  17. Why do we copy then move?
  18. Non-copyable elements in vector
  19. Can I typically/always use std::forward instead of std::move?
  20. Should I delete the move constructor and the move assignment of a smart pointer?
  21. copy vs std::move for ints
  22. Do built-in types have move semantics?
  23. Is there any case where a return of a RValue Reference (&&) is useful?
  24. When to make a type non-movable in C++11?
  25. Is std::array movable?
  26. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom 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. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  30. Move constructor on derived object

Leave a Comment