std::shared_ptr not managing circular references properly in C++11 with custom deleters
I'm writing unit tests and I'm working with an scenario with `std::shared_ptr` where I'm trying to manage a set of objects that have circular references. Specifically, I have two classes, `A` and `B`, where `A` holds a `std::shared_ptr<B>` and `B` holds a `std::shared_ptr<A>`. I am using custom deleters to manage the memory, but it seems like I'm running into a memory leak question. When I run my application, I notice that the memory usage keeps increasing over time, which points to a failure in deallocating these objects. Here's a simplified version of my code: ```cpp #include <iostream> #include <memory> class B; // Forward declaration class A { public: std::shared_ptr<B> b; A() { std::cout << "A created" << std::endl; } ~A() { std::cout << "A destroyed" << std::endl; } }; class B { public: std::shared_ptr<A> a; B() { std::cout << "B created" << std::endl; } ~B() { std::cout << "B destroyed" << std::endl; } }; int main() { std::shared_ptr<A> a = std::make_shared<A>(); std::shared_ptr<B> b = std::make_shared<B>(); a->b = b; b->a = a; return 0; } ``` Despite the destructors being defined, they are never called when I exit the `main` function, suggesting that the circular references are preventing the objects from being deleted. I tried using `std::weak_ptr` for the reference in class `B` instead of `std::shared_ptr`, but Iām not sure how to correctly implement that within the context of my current code. Could someone provide guidance on how to properly resolve circular references with `std::shared_ptr` and ensure that memory is managed correctly? I'm using C++11 and I've read about `std::weak_ptr`, but I'm not clear on how to implement it effectively in this situation. Any help would be greatly appreciated! For context: I'm using C++ on Windows. I'd really appreciate any guidance on this. I'm using C++ 3.9 in this project.