How do shared pointers work?

by

Basically, shared_ptr has two pointers: a pointer to the shared object and a pointer to a struct containing two reference counts: one for “strong references,” or references that have ownership, and one for “weak references,” or references that don’t have ownership.

When you copy a shared_ptr, the copy constructor increments the strong reference count. When you destroy a shared_ptr, the destructor decrements the strong reference count and tests whether the reference count is zero; if it is, the destructor deletes the shared object because no shared_ptrs point to it anymore.

The weak reference count is used to support weak_ptr; basically, any time a weak_ptr is created from the shared_ptr, the weak reference count is incremented, and any time one is destroyed the weak reference count is decremented. As long as either the strong reference count or the weak reference count is greater than zero, the reference count struct will not be destroyed.

Effectively, as long as the strong reference count is greater than zero, the shared object will not be deleted. As long as the strong reference count or the weak reference count is not zero, the reference count struct will not be deleted.

More Related Contents:

  1. How do I call ::std::make_shared on a class with only protected or private constructors?
  2. shared_ptr to an array : should it be used?
  3. Difference in make_shared and normal shared_ptr in C++
  4. Differences between unique_ptr and shared_ptr [duplicate]
  5. Why isn’t there a std::shared_ptr specialisation?
  6. Why do std::shared_ptr work
  7. Should we pass a shared_ptr by reference or by value?
  8. Passing shared pointers as arguments
  9. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  10. Passing shared_ptr as shared_ptr
  11. Where is shared_ptr?
  12. std::shared_ptr thread safety explained
  13. Should I use shared_ptr or unique_ptr
  14. What is the difference between an empty and a null std::shared_ptr in C++?
  15. Why would I std::move an std::shared_ptr?
  16. shared_ptr and weak_ptr differences
  17. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  18. weak_ptr, make_shared and memory deallocation
  19. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  20. Implementation C++14 make_integer_sequence
  21. Range based loop: get item by value or reference to const?
  22. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  23. How to automatically convert strongly typed enum into int?
  24. How to implement multithread safe singleton in C++11 without using
  25. How to guarantee order of argument evaluation when calling a function object?
  26. Is it possible to std::move objects out of functions? (C++11)
  27. Delayed start of a thread in C++ 11
  28. Lookup table with constexpr
  29. What is the purpose of std::function and how to use it?
  30. const auto std::initializer_list difference between Clang and GCC

Leave a Comment