std::weak_ptr: Breaking Circular References and Observer Patterns0%

Custom Deleters for Smart Pointers (C APIs, File Handles)

std::weak_ptr: Breaking Circular References and Observer Patterns

Advanced13 min read•Updated: 2026-10-22

🕸️ std::weak_ptr: Breaking Circular References

Introduction

While std::shared_ptr is powerful, cyclic relationships (where Object A holds a shared_ptr to Object B, and Object B holds a shared_ptr back to Object A) cause a fatal circular reference: neither reference count can ever reach zero, resulting in a permanent silent memory leak. std::weak_ptr solves this by holding a non-owning observer reference.

🔄 The Circular Reference Deadlock

1#include <iostream>
2#include <memory>
3 
4struct NodeB; // Forward declaration
5 
6struct NodeA {
7    std::shared_ptr<NodeB> nextB;
8    ~NodeA() { std::cout << "NodeA destroyed\n"; }
9};
10 
11struct NodeB {
12    // ❌ Circular reference if shared_ptr:
13    // std::shared_ptr<NodeA> prevA;
14 
15    // ✅ Safe non-owning reference breaks the cycle:
16    std::weak_ptr<NodeA> prevA;
17    ~NodeB() { std::cout << "NodeB destroyed\n"; }
18};
19 
20int main() {
21    {
22        auto a = std::make_shared<NodeA>();
23        auto b = std::make_shared<NodeB>();
24 
25        a->nextB = b;
26        b->prevA = a; // Weak pointer does NOT increment a's reference count!
27    } // Both nodes are cleanly destroyed without leaks!
28 
29    return 0;
30}

🔒 Accessing a `weak_ptr` via `.lock()`

Because a weak_ptr does not prevent object destruction, you cannot dereference it directly. You must call .lock(), which safely returns an std::shared_ptr if the object is still alive:

1std::weak_ptr<NodeA> weakHandle = a;
2 
3if (auto activePtr = weakHandle.lock()) {
4    // Resource is still alive! Safe to access activePtr->
5} else {
6    // Resource was already destroyed!
7}

Next Lesson

Custom Deleters for Smart Pointers (C APIs, File Handles)

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
std::shared_ptr: Shared Reference-Counted Ownership and std::make_shared	Custom Deleters for Smart Pointers (C APIs, File Handles)

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Custom Deleters for Smart Pointers (C APIs, File Handles)

std::weak_ptr: Breaking Circular References and Observer Patterns

Advanced13 min read•Updated: 2026-10-22

Study Materials

🕸️ std::weak_ptr: Breaking Circular References

Introduction

🔄 The Circular Reference Deadlock

1#include <iostream>
2#include <memory>
3 
4struct NodeB; // Forward declaration
5 
6struct NodeA {
7    std::shared_ptr<NodeB> nextB;
8    ~NodeA() { std::cout << "NodeA destroyed\n"; }
9};
10 
11struct NodeB {
12    // ❌ Circular reference if shared_ptr:
13    // std::shared_ptr<NodeA> prevA;
14 
15    // ✅ Safe non-owning reference breaks the cycle:
16    std::weak_ptr<NodeA> prevA;
17    ~NodeB() { std::cout << "NodeB destroyed\n"; }
18};
19 
20int main() {
21    {
22        auto a = std::make_shared<NodeA>();
23        auto b = std::make_shared<NodeB>();
24 
25        a->nextB = b;
26        b->prevA = a; // Weak pointer does NOT increment a's reference count!
27    } // Both nodes are cleanly destroyed without leaks!
28 
29    return 0;
30}

🔒 Accessing a `weak_ptr` via `.lock()`

Because a weak_ptr does not prevent object destruction, you cannot dereference it directly. You must call .lock(), which safely returns an std::shared_ptr if the object is still alive:

1std::weak_ptr<NodeA> weakHandle = a;
2 
3if (auto activePtr = weakHandle.lock()) {
4    // Resource is still alive! Safe to access activePtr->
5} else {
6    // Resource was already destroyed!
7}

Next Lesson

Custom Deleters for Smart Pointers (C APIs, File Handles)

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
std::shared_ptr: Shared Reference-Counted Ownership and std::make_shared	Custom Deleters for Smart Pointers (C APIs, File Handles)

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

🕸️ std::weak_ptr: Breaking Circular References

Introduction

🔄 The Circular Reference Deadlock

🔒 Accessing a weak_ptr via .lock()

Custom Deleters for Smart Pointers (C APIs, File Handles)

Related Lessons

Practice Quiz

Loading Page Content...

🕸️ std::weak_ptr: Breaking Circular References

Introduction

🔄 The Circular Reference Deadlock

🔒 Accessing a weak_ptr via .lock()

Custom Deleters for Smart Pointers (C APIs, File Handles)

Related Lessons

Practice Quiz

🔒 Accessing a `weak_ptr` via `.lock()`

🔒 Accessing a `weak_ptr` via `.lock()`