Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Learn Breaking Circular References With Weak Pointers | Weak Pointers
C++ Smart Pointers
course content

Course Content

C++ Smart Pointers

C++ Smart Pointers

1. Introduction to Smart Pointers
Understanding PointersDynamic memory allocationThe Need For Smart Pointers
2. Unique Pointers
Introduction to Unique PointersMoving Unique PointersApplication For Unique PointersPassing Around Unique PointersMethods of a Unique Pointer
3. Shared Pointers
Introduction to Shared PointersCreating and Sharing Shared PointersCircular References and Shared Pointers
4. Weak Pointers
Introduction to Weak PointersCreating And Using Weak PointersBreaking Circular References With Weak PointersImportant Weak Pointer Functions
5. Advanced topics
Providing Custom Deleters For Smart PointersPerformance Considerations With Smart PointersOverview Shared vs Unique vs Weak Pointers

book
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.

cpp

main

copy

              
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!

question mark

The following code has two shared pointers A and B both sharing a resource. Modify it so that B becomes a weak pointer.

Select the correct answer

Everything was clear?

How can we improve it?

Thanks for your feedback!

Section 4. Chapter 3
We're sorry to hear that something went wrong. What happened?
some-alt