编辑“︁C++ weak ptr 详解”︁

= C++ weak_ptr详解 =

== 介绍 ==
'''weak_ptr''' 是 C++11 引入的智能指针之一，用于解决 shared_ptr 的循环引用问题。它不拥有对象的所有权，而是'''观察'''一个由 shared_ptr 管理的对象。当最后一个 shared_ptr 被销毁时，weak_ptr 会自动感知到目标对象已被释放，避免了悬挂指针的风险。

weak_ptr 的主要特点：
* 不增加引用计数
* 必须通过 lock() 方法转换为 shared_ptr 才能访问对象
* 常用于打破 shared_ptr 的循环引用

== 基本用法 ==

=== 创建 weak_ptr ===
weak_ptr 通常通过 shared_ptr 构造或赋值：

<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> shared = std::make_shared<int>(42);
    std::weak_ptr<int> weak(shared);  // 从shared_ptr构造
    
    // 检查weak_ptr是否有效
    if (!weak.expired()) {
        std::cout << "weak_ptr is observing a valid object\n";
    }
    
    return 0;
}
</syntaxhighlight>

输出：
<pre>
weak_ptr is observing a valid object
</pre>

=== 访问对象 ===
weak_ptr 不能直接访问对象，必须通过 lock() 方法获取一个临时的 shared_ptr：

<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> shared = std::make_shared<int>(100);
    std::weak_ptr<int> weak = shared;
    
    if (auto tempShared = weak.lock()) {  // 转换为shared_ptr
        std::cout << "Value: " << *tempShared << "\n";
    } else {
        std::cout << "Object no longer exists\n";
    }
    
    shared.reset();  // 释放对象
    
    if (weak.expired()) {
        std::cout << "Object has been deleted\n";
    }
    
    return 0;
}
</syntaxhighlight>

输出：
<pre>
Value: 100
Object has been deleted
</pre>

== 循环引用问题 ==

weak_ptr 最常见的用途是解决 shared_ptr 的循环引用问题。考虑以下场景：

<mermaid>
graph LR
    A[shared_ptr A] --> B[Object B]
    B --> C[shared_ptr C]
    C --> A
</mermaid>

=== 问题示例 ===
<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    
    node1->next = node2;
    node2->next = node1;  // 循环引用
    
    return 0;  // 对象不会被销毁！
}
</syntaxhighlight>

=== 解决方案 ===
使用 weak_ptr 打破循环：

<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

struct Node {
    std::weak_ptr<Node> next;  // 改为weak_ptr
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    
    node1->next = node2;
    node2->next = node1;  // weak_ptr不会增加引用计数
    
    return 0;  // 对象会被正确销毁
}
</syntaxhighlight>

输出：
<pre>
Node destroyed
Node destroyed
</pre>

== 实际应用场景 ==

=== 缓存系统 ===
weak_ptr 非常适合实现对象缓存，当外部不再需要对象时，缓存可以自动释放：

<syntaxhighlight lang="cpp">
#include <memory>
#include <unordered_map>
#include <iostream>

class Cache {
    std::unordered_map<int, std::weak_ptr<std::string>> cache;
    
public:
    std::shared_ptr<std::string> get(int id) {
        auto it = cache.find(id);
        if (it != cache.end()) {
            return it->second.lock();  // 返回shared_ptr或nullptr
        }
        return nullptr;
    }
    
    void store(int id, std::shared_ptr<std::string> value) {
        cache[id] = value;
    }
};

int main() {
    Cache cache;
    
    {
        auto data = std::make_shared<std::string>("Important Data");
        cache.store(1, data);
        
        if (auto cached = cache.get(1)) {
            std::cout << *cached << "\n";  // 输出: Important Data
        }
    }  // data离开作用域，被销毁
    
    if (auto cached = cache.get(1)) {
        std::cout << "Data still exists\n";
    } else {
        std::cout << "Data has been released\n";  // 会执行这一行
    }
    
    return 0;
}
</syntaxhighlight>

=== 观察者模式 ===
weak_ptr 可用于实现观察者模式，避免观察者意外延长被观察对象的生命周期：

<syntaxhighlight lang="cpp">
#include <memory>
#include <vector>
#include <iostream>

class Subject;

class Observer {
public:
    virtual void update() = 0;
    virtual ~Observer() = default;
};

class Subject {
    std::vector<std::weak_ptr<Observer>> observers;
    
public:
    void attach(std::weak_ptr<Observer> obs) {
        observers.push_back(obs);
    }
    
    void notify() {
        for (auto& weak_obs : observers) {
            if (auto obs = weak_obs.lock()) {
                obs->update();
            }
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        std::cout << "Observer notified!\n";
    }
};

int main() {
    auto subject = std::make_shared<Subject>();
    auto observer = std::make_shared<ConcreteObserver>();
    
    subject->attach(observer);
    subject->notify();  // 输出: Observer notified!
    
    return 0;
}
</syntaxhighlight>

== 性能考虑 ==

* weak_ptr 的操作（如 lock()）比 shared_ptr 稍慢，因为需要检查引用计数
* 每个 weak_ptr 会增加少量内存开销（控制块中需要维护 weak count）
* 在性能关键路径中应谨慎使用

== 数学原理 ==

weak_ptr 的引用计数机制可以用以下公式表示：

<math>
\begin{cases}
\text{对象存活} & \text{当且仅当} \quad \text{shared\_count} > 0 \\
\text{weak\_count} & \text{表示有多少 weak\_ptr 正在观察该对象}
\end{cases}
</math>

即使 shared_count 降为 0，只要 weak_count > 0，控制块仍会保留，直到 weak_count 也降为 0。

== 最佳实践 ==

1. 优先使用 shared_ptr 和 unique_ptr，只在必要时使用 weak_ptr
2. 每次访问 weak_ptr 前都应检查是否 expired() 或验证 lock() 的返回值
3. 避免长期持有 weak_ptr，这可能导致控制块无法释放
4. 在多线程环境中使用时，lock() 操作是线程安全的

== 总结 ==

weak_ptr 是 C++ 智能指针家族中的重要成员，它：
* 解决了 shared_ptr 的循环引用问题
* 实现了非拥有式观察语义
* 广泛应用于缓存、观察者模式等场景
* 需要配合 lock() 方法安全访问对象

正确使用 weak_ptr 可以显著提高 C++ 程序的资源管理能力和安全性。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 智能指针]]