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!

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 4. Luku 3

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

Kurssisisältö

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
}

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 4. Luku 3