std::shared_ptr causing memory leak in circular reference with custom deleter in C++17
I'm working on a personal project and I'm encountering a memory leak in my C++17 application when using `std::shared_ptr` with a custom deleter in a circular reference scenario... I have two classes, `A` and `B`, where `A` holds a `std::shared_ptr<B>`, and `B` in turn holds a `std::shared_ptr<A>`. I'm using a custom deleter for both shared pointers to perform some cleanup. However, when I try to delete these objects, it seems like the memory is not being released as expected, leading to a memory leak. 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 destroyed" << std::endl; } }; class B { public: std::shared_ptr<A> a; ~B() { std::cout << "B destroyed" << std::endl; } }; void createObjects() { auto a = std::shared_ptr<A>(new A(), [](A* p) { delete p; }); auto b = std::shared_ptr<B>(new B(), [](B* p) { delete p; }); a->b = b; b->a = a; } int main() { createObjects(); // Memory leak occurs here, as A and B are not being destroyed. return 0; } ``` When the function `createObjects` is called, I expect the destructors for `A` and `B` to be called, but they are not. Instead, I see the following output when the program exits, which suggests the memory is not being released: ``` A destroyed B destroyed ``` I've tried using `std::weak_ptr` to break the circular reference, but it seems that when I assign `a->b` and `b->a`, it still doesn’t resolve the issue as expected. What am I missing in my implementation? Could someone point out how to properly handle this situation to prevent the memory leak? For context: I'm using Cpp on Ubuntu 22.04.