Shared Pointer Cyclic References

If two shared pointers reference each other, it will create a cyclic reference, which will prevent the objects from being deleted and will cause a memory leak.

Consider this example:

1#include <memory>
2
3class Node {
4public:
5  std::shared_ptr<Node> next;
6};
7
8int main() {
9  auto node1 = std::make_shared<Node>();
10  auto node2 = std::make_shared<Node>();
11
12  node1->next = node2;
13  node2->next = node1;
14}

In this code, node1 and node2 are shared pointers to Nodeobjects. The Node objects contain a shared_ptr member variable next, which is used to make node1 point to node2, and node2 point back to node1.

The problem is that when main ends, node1 and node2 will be destroyed. However, their destructor won't delete the Node objects they point to, because each Node object is still referenced by the other Node's next pointer.

As a result, the memory for these Node objects will never be freed, causing a memory leak.

To solve this problem, we can use weak pointers (std::weak_ptr). A weak pointer is a non-owning reference to an object managed by a shared pointer. It doesn't contribute to the reference count, so it doesn't prevent the object from being deleted.

Here's how we could use weak pointers to avoid the cyclic reference:

1#include <memory>
2
3class Node {
4public:
5  std::weak_ptr<Node> next;
6};
7
8int main() {
9  auto node1 = std::make_shared<Node>();
10  auto node2 = std::make_shared<Node>();
11
12  node1->next = node2;
13  node2->next = node1;
14}

Now, when node1 and node2 are destroyed, the Node objects they point to will also be deleted, because the weak pointers in the next members don't prevent the reference count from reaching zero.

However, using weak pointers comes with its own set of challenges. Because a weak pointer doesn't guarantee that the object it points to still exists, you have to convert it to a shared pointer before you can use it, and you have to check that the conversion succeeded.

This adds some complexity to the code, but it's necessary to avoid memory leaks in structures that could contain cyclic references, like graphs or trees.