How to avoid memory leak with shared_ptr?

Question

Consider the following code.

using boost::shared_ptr; struct B; struct A{     ~A() { std::cout << "~A" << std::endl; }     shared_ptr<B> b;     }; struct B {     ~B() { std::cout << "~B" << std::endl; }     shared_ptr<A> a; };  int main() {     shared_ptr<A> a (new A);     shared_ptr<B> b (new B);     a->b = b;     b->a = a;      return 0; } 

There is no output. No desctructor is called. Memory leak. I have always believed that the smart pointer helps avoid memory leaks.

What should I do if I need cross-references in the classes?

Answer 1

If you have circular references like this, one object should hold a weak_ptr to the other, not a shared_ptr.

From the shared_ptr introduction:

Because the implementation uses reference counting, cycles of shared_ptr instances will not be reclaimed. For example, if main() holds a shared_ptr to A, which directly or indirectly holds a shared_ptr back to A, A's use count will be 2. Destruction of the original shared_ptr will leave A dangling with a use count of 1. Use weak_ptr to "break cycles."

Thanks, Glen, for the link.