Breaking Circular References With Weak Pointers

Weak pointers are designed to break circular references. By replacing a std::shared_ptr in a circular dependency with a std::weak_ptr, we prevent objects from unintentionally extending each other's lifetimes, allowing proper destruction.

main.cpp


              12345678910111213141516171819202122232425
            
#include <iostream>
#include <memory>

class Node {
public:
    Node() { std::cout << "Node constructed." << std::endl; }
    ~Node() { std::cout << "Node destructed." << std::endl; }

    // A weak pointer to the next element prevents circular ownership.
    std::weak_ptr<Node> next;
};

int main() 
{
    // Creating three Node objects.
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    std::shared_ptr<Node> node3 = std::make_shared<Node>();

    // Creating a list where the last node's next is a weak pointer
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;
    // Now when node1, node2, and node3 go out of scope, their destructors will be called
}

The circular reference problem is resolved by changing next from a std::shared_ptr to a std::weak_ptr. Follow the comments in the code for a clearer understanding. Run the code to confirm that the destructors are now called properly no memory leaks!

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 4. Kapittel 3

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Kursinnhold

C++ Smart Pointers

1. Introduction to Smart Pointers

Understanding Pointers Dynamic memory allocation The Need For Smart Pointers

2. Unique Pointers

Introduction to Unique Pointers Moving Unique Pointers Application For Unique Pointers Passing Around Unique Pointers Methods of a Unique Pointer

3. Shared Pointers

Introduction to Shared Pointers Creating and Sharing Shared Pointers Circular References and Shared Pointers

4. Weak Pointers

Introduction to Weak Pointers Creating And Using Weak Pointers Breaking Circular References With Weak Pointers Important Weak Pointer Functions

5. Advanced topics

Providing Custom Deleters For Smart Pointers Performance Considerations With Smart Pointers Overview Shared vs Unique vs Weak Pointers

Breaking Circular References With Weak Pointers

main.cpp


              12345678910111213141516171819202122232425
            
#include <iostream>
#include <memory>

class Node {
public:
    Node() { std::cout << "Node constructed." << std::endl; }
    ~Node() { std::cout << "Node destructed." << std::endl; }

    // A weak pointer to the next element prevents circular ownership.
    std::weak_ptr<Node> next;
};

int main() 
{
    // Creating three Node objects.
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    std::shared_ptr<Node> node3 = std::make_shared<Node>();

    // Creating a list where the last node's next is a weak pointer
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;
    // Now when node1, node2, and node3 go out of scope, their destructors will be called
}

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 4. Kapittel 3