I have read that weak_pointers can be used to break cyclic references.
Consider the following example of a cyclic reference
struct A
{
boost::shared_ptr<A> shrd_ptr;
};
boost::shared_ptr<A> ptr_A(boost::make_shared<A>());
boost::shared_ptr<A> ptr_b(boost::make_shared<A>());
ptr_A->shrd_ptr = ptr_b;
ptr_b->shrd_ptr = ptr_A;
Now above is a case of cyclic reference and I wanted to know how I can break
the cyclic reference above by using weak_ptr
?
Update : Based on suggestion received I came up with the following :
struct A
{
boost::weak_ptr<A> wk_ptr;
};
boost::shared_ptr<A> ptr_A (boost::make_shared<A>());
boost::shared_ptr<A> ptr_B (boost::make_shared<A>());
ptr_A->wk_ptr = ptr_B;
ptr_B->wk_ptr = ptr_A;
Will this be the correct approach ?
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.
Edit: In your case, the approach you suggested looks perfectly valid. Take ownership away from A
and something else owns the A
s.