C++的std::weak_ptr是如何解决shared_ptr循环引用问题的

std::weak_ptr的核心作用是打破shared_ptr的循环引用，避免内存泄漏。它通过不增加引用计数的方式观察对象，在对象仍存活时可升级为shared_ptr访问，从而实现非拥有的安全引用。

std::weak_ptr

std::shared_ptr

shared_ptr

weak_ptr

解决方案

要理解

std::weak_ptr

std::shared_ptr

shared_ptr

shared_ptr

shared_ptr

问题就出在，如果两个对象 A 和 B，A 持有 B 的

shared_ptr

shared_ptr

shared_ptr

std::weak_ptr

shared_ptr

weak_ptr

立即学习“C++免费学习笔记（深入）”；

举个例子，假设我们有一个

Node

nodeA

nodeB

shared_ptr

class Node {
public:
    std::shared_ptr<Node> next;
    // ... 其他数据 ...

    ~Node() {
        std::cout << "Node destroyed." << std::endl;
    }
};

// 循环引用示例
void demonstrate_circular_reference() {
    auto nodeA = std::make_shared<Node>();
    auto nodeB = std::make_shared<Node>();

    nodeA->next = nodeB;
    nodeB->next = nodeA;
    // 此时 nodeA 和 nodeB 的引用计数都为 2
    // 外部对 nodeA 和 nodeB 的 shared_ptr 离开作用域后，它们的引用计数会降到 1
    // 但因为互相持有，永远不会降到 0，导致内存泄漏
}

要解决这个问题，我们可以让其中一个

next

std::weak_ptr

class Node {
public:
    std::shared_ptr<Node> next_strong; // 强引用，参与计数
    std::weak_ptr<Node> next_weak;     // 弱引用，不参与计数
    // ... 其他数据 ...

    ~Node() {
        std::cout << "Node destroyed." << std::endl;
    }
};

void solve_circular_reference() {
    auto nodeA = std::make_shared<Node>();
    auto nodeB = std::make_shared<Node>();

    nodeA->next_strong = nodeB; // A 强引用 B
    nodeB->next_weak = nodeA;   // B 弱引用 A

    // 此时 nodeA 的强引用计数为 1 (外部) + 0 (来自 next_weak，不计数) = 1
    // nodeB 的强引用计数为 1 (外部) + 1 (来自 next_strong) = 2
    // 外部 shared_ptr 离开作用域后：
    // nodeB 的强引用计数降到 1 (来自 nodeA->next_strong)
    // nodeA 的强引用计数降到 0，nodeA 被销毁。
    // nodeA 被销毁后，nodeA->next_strong 也被销毁，导致 nodeB 的强引用计数降到 0，nodeB 被销毁。
}

通过这种方式，

nodeB

nodeA

nodeA

nodeA

nodeA

nodeA

nodeB

nodeB

std::weak_ptr究竟是如何工作的？它与shared_ptr有何本质区别？

std::weak_ptr

std::shared_ptr

shared_ptr

std::make_shared

std::shared_ptr

std::weak_ptr

weak_ptr

weak_ptr

weak_ptr

weak_ptr

lock()

weak_ptr::lock()

lock()

std::shared_ptr

lock()

std::shared_ptr

这种机制的本质区别在于所有权：

shared_ptr

weak_ptr

在哪些实际场景中，我们应该优先考虑使用std::weak_ptr？

std::weak_ptr

1. 父子关系中子节点对父节点的引用：在许多数据结构中，父节点拥有子节点（通过

   shared_ptr

   登录后复制
   ），但子节点可能需要反向引用其父节点。如果子节点也用

   shared_ptr

   登录后复制
   引用父节点，就会形成循环。此时，子节点内部使用

   weak_ptr

   登录后复制
   引用父节点是最佳选择。父节点可以被销毁，而子节点仍然可以判断父节点是否存在。
   

   AI建筑知识问答

   用人工智能ChatGPT帮你解答所有建筑问题

   22

   查看详情

2. 观察者模式（Observer Pattern）：在观察者模式中，一个主题（Subject）可能被多个观察者（Observer）订阅。如果主题持有观察者的

   shared_ptr

   登录后复制
   ，而观察者又需要持有主题的

   shared_ptr

   登录后复制
   （例如，为了在取消订阅时使用），也会产生循环。让主题持有观察者的

   weak_ptr

   登录后复制
   ，可以确保观察者在不再被其他地方引用时能够被销毁，同时主题也能安全地检查观察者是否仍然有效。

3. 缓存机制：当你实现一个缓存系统时，你可能希望缓存中的对象在没有其他强引用时能够被自动清除。如果缓存持有对象的

   shared_ptr

   登录后复制
   ，那么对象将永远不会被释放。通过让缓存持有对象的

   weak_ptr

   登录后复制
   ，一旦外部不再有强引用，对象就能被回收，而缓存中的

   weak_ptr

   登录后复制
   会失效，下次访问时发现对象已不存在，便可将其从缓存中移除。

4. 图或复杂数据结构中的节点：在图结构中，节点之间可能存在复杂的相互引用。为了避免循环引用导致内存泄漏，通常会策略性地使用

   weak_ptr

   登录后复制
   来处理某些方向的引用，尤其是在双向链表或图的边表示中。

5. 跨线程或异步操作中的对象生命周期管理：当一个对象需要在后台线程中进行处理，并且处理结果可能在对象生命周期结束后才返回时，如果后台任务持有对象的

   shared_ptr

   登录后复制
   ，可能会不必要地延长对象的生命周期。使用

   weak_ptr

   登录后复制
   可以在任务开始时尝试

   lock()

   登录后复制
   获取

   shared_ptr

   登录后复制
   ，如果成功，则说明对象仍然存在且可以安全访问；如果失败，则说明对象已销毁，任务可以安全终止或跳过。

我个人在设计一些复杂系统时，尤其是在涉及回调和事件处理的场景下，发现

weak_ptr

使用std::weak_ptr时有哪些常见的陷阱和最佳实践？

虽然

std::weak_ptr

shared_ptr

1. 务必检查

   lock()

   登录后复制
   的结果：这是最重要的一点。

   weak_ptr

   登录后复制
   所指向的对象随时可能被销毁，因此在尝试使用它之前，必须通过

   lock()

   登录后复制
   方法获取一个

   shared_ptr

   登录后复制
   ，并检查这个

   shared_ptr

   登录后复制
   是否为空。忘记检查

   lock()

   登录后复制
   的结果，直接解引用一个可能已经失效的

   weak_ptr

   登录后复制
   ，会导致未定义行为（通常是程序崩溃）。

   std::weak_ptr<MyClass> weakPtr;
   // ... somewhere else, the shared_ptr might have expired ...
   
   if (auto sharedPtr = weakPtr.lock()) {
       // 对象仍然存在，可以安全使用 sharedPtr
       sharedPtr->doSomething();
   } else {
       // 对象已失效，sharedPtr 为空
       std::cout << "对象已销毁，无法执行操作。" << std::endl;
   }

   登录后复制

2. weak_ptr

   登录后复制
   不能直接解引用：

   weak_ptr

   登录后复制
   不提供

   operator*

   登录后复制
   或

   operator->

   登录后复制
   。你必须先通过

   lock()

   登录后复制
   方法将其转换为

   shared_ptr

   登录后复制
   才能访问底层对象。这是其非拥有性质的体现。

3. weak_ptr

   登录后复制
   不适合作为通用指针：不要用

   weak_ptr

   登录后复制
   替代

   unique_ptr

   登录后复制
   或裸指针，除非你明确需要其非拥有、可失效的特性来解决特定问题（如循环引用或观察者模式）。在大多数情况下，如果一个对象是独占所有权，用

   unique_ptr

   登录后复制
   ；如果生命周期由其创建者控制且不涉及共享所有权，用裸指针（注意生命周期管理）。

   weak_ptr

   登录后复制
   引入了额外的开销，包括原子操作和控制块的管理。

4. 避免

   weak_ptr

   登录后复制
   指向栈对象：

   weak_ptr

   登录后复制
   是为

   shared_ptr

   登录后复制
   管理的堆对象设计的。如果你尝试创建一个指向栈上对象的

   shared_ptr

   登录后复制
   ，然后从它创建

   weak_ptr

   登录后复制
   ，这本身就是不规范的，因为

   shared_ptr

   登录后复制
   通常用于管理动态分配的资源。当栈对象超出作用域时，

   shared_ptr

   登录后复制
   会认为它已经管理了对象的生命周期，但实际上对象已经由栈自动销毁，这会导致未定义行为。

5. 性能开销：

   weak_ptr::lock()

   登录后复制
   内部会涉及原子操作来尝试增加强引用计数，这会带来一定的性能开销。在性能敏感的代码路径中，如果能通过其他方式（如事件通知或生命周期保证）避免使用

   weak_ptr

   登录后复制
   ，可能更优。但通常情况下，这点开销是值得的，因为它换来了正确的内存管理和更高的代码健壮性。

6. 初始化问题：

   weak_ptr

   登录后复制
   可以从

   shared_ptr

   登录后复制
   或另一个

   weak_ptr

   登录后复制
   初始化。但不能从裸指针直接初始化。你必须先有一个

   shared_ptr

   登录后复制
   来管理对象，然后才能创建

   weak_ptr

   登录后复制
   。

我曾经在项目中遇到过一个非常隐蔽的 bug，就是因为在回调函数中使用了

weak_ptr

lock()

weak_ptr

weak_ptr

if (auto sp = wp.lock()) { ... }

以上就是C++的std::weak_ptr是如何解决shared_ptr循环引用问题的的详细内容，更多请关注php中文网其它相关文章！