Why would I std::move an std::shared_ptr?

by

I think that the one thing the other answers did not emphasize enough is the point of speed.

std::shared_ptr reference count is atomic. increasing or decreasing the reference count requires atomic increment or decrement. This is hundred times slower than non-atomic increment/decrement, not to mention that if we increment and decrement the same counter we wind up with the exact number, wasting a ton of time and resources in the process.

By moving the shared_ptr instead of copying it, we “steal” the atomic reference count and we nullify the other shared_ptr. “stealing” the reference count is not atomic, and it is hundred times faster than copying the shared_ptr (and causing atomic reference increment or decrement).

Do note that this technique is used purely for optimization. copying it (as you suggested) is just as fine functionality-wise.

More Related Contents:

  1. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  2. Passing shared_ptr as shared_ptr
  3. Where is shared_ptr?
  4. Should I delete the move constructor and the move assignment of a smart pointer?
  5. What is “rvalue reference for *this”?
  6. C++11 rvalues and move semantics confusion (return statement)
  7. How do I call ::std::make_shared on a class with only protected or private constructors?
  8. initializer_list and move semantics
  9. When should std::move be used on a function return value? [duplicate]
  10. Difference in make_shared and normal shared_ptr in C++
  11. What is the advantage of using forwarding references in range-based for loops?
  12. Is there any use for unique_ptr with array?
  13. “Downcasting” unique_ptr to unique_ptr
  14. Why is `std::move` named `std::move`?
  15. What does the standard library guarantee about self move assignment?
  16. How much is the overhead of smart pointers compared to normal pointers in C++?
  17. How to actually implement the rule of five?
  18. copy vs std::move for ints
  19. Do built-in types have move semantics?
  20. std::auto_ptr to std::unique_ptr
  21. When to make a type non-movable in C++11?
  22. Why is auto_ptr being deprecated?
  23. What is the difference between an empty and a null std::shared_ptr in C++?
  24. Is std::array movable?
  25. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  26. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  27. C++: std::move with rvalue reference is not moving contents
  28. What is std::move(), and when should it be used and does it actually move anything?
  29. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  30. Move constructor on derived object

Leave a Comment