How to break shared_ptr cyclic reference using weak_ptr

by

The classic example of cyclic references is where you have two classes A and B where A has a reference to B which has a reference to A:

#include <memory>
#include <iostream>

struct B;
struct A {
  std::shared_ptr<B> b;  
  ~A() { std::cout << "~A()\n"; }
};

struct B {
  std::shared_ptr<A> a;
  ~B() { std::cout << "~B()\n"; }  
};

void useAnB() {
  auto a = std::make_shared<A>();
  auto b = std::make_shared<B>();
  a->b = b;
  b->a = a;
}

int main() {
   useAnB();
   std::cout << "Finished using A and B\n";
}

If both references are shared_ptr then that says A has ownership of B and B has ownership of A, which should ring alarm bells. In other words, A keeps B alive and B keeps A alive.

In this example the instances a and b are only used in the useAnB() function so we would like them to be destroyed when the function ends but as we can see when we run the program the destructors are not called.

The solution is to decide who owns who. Lets say A owns B but B does not own A then we replace the reference to A in B with a weak_ptr like so:

struct B {
  std::weak_ptr<A> a;
  ~B() { std::cout << "~B()\n"; }  
};

Then if we run the program we see that a and b are destroyed as we expect.

Live demo

Edit: In your case, the approach you suggested looks perfectly valid. Take ownership away from A and something else owns the As.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. RAII and smart pointers in C++
  3. How can I pass a class member function as a callback?
  4. Why can I not push_back a unique_ptr into a vector?
  5. Does “&s[0]” point to contiguous characters in a std::string?
  6. Differences between std::make_unique and std::unique_ptr with new
  7. What C++ Smart Pointer Implementations are available?
  8. “Downcasting” unique_ptr to unique_ptr
  9. Can virtual functions have default parameters?
  10. How much is the overhead of smart pointers compared to normal pointers in C++?
  11. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  12. smart pointers and arrays
  13. Default, value and zero initialization mess
  14. How to avoid memory leak with shared_ptr?
  15. When to use shared_ptr and when to use raw pointers?
  16. Passing shared_ptr as shared_ptr
  17. Should I delete the move constructor and the move assignment of a smart pointer?
  18. Return Type Covariance with Smart Pointers
  19. Do these members have unspecified ordering?
  20. Can C++ code be valid in both C++03 and C++11 but do different things?
  21. How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?
  22. Can Google Mock a method with a smart pointer return type?
  23. Is auto_ptr deprecated?
  24. unique_ptr and OpenSSL’s STACK_OF(X509)*
  25. Why would I std::move an std::shared_ptr?
  26. What differences, if any, between C++03 and C++11 can be detected at run-time?
  27. Example to use shared_ptr?
  28. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  29. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  30. Calling delete on NULL pointers – C++03 vs C++11

Leave a Comment