How do circular references affect smart pointers in C++11?

What are circular references in C++11 smart pointers?

Circular references occur when two or more smart pointers reference each other, preventing memory from being freed.

How can I avoid circular references when using smart pointers?

You can use std::weak_ptr to break the circular reference, allowing the memory to be freed when no longer needed.

Can you give me an example of using weak_ptr?

Sure! Here's a simple example:

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->next = node1; // This creates a circular reference
    
    // To avoid this, use weak_ptr:
    std::weak_ptr<Node> weakNode1 = node1;
    std::weak_ptr<Node> weakNode2 = node2;
}

What happens if I don't manage circular references?

If you don't manage circular references, it can lead to memory leaks because the memory allocated for the objects will not be freed.