C++weak_ptr解决循环引用问题技巧（循环.引用.解决.技巧.weak_ptr...）

wufei123 发布于 2025-09-11 阅读（1）
weak_ptr通过不增加引用计数的非拥有引用打破shared_ptr循环引用，当对象仅被weak_ptr指向时仍可被释放，从而避免内存泄漏。

c++weak_ptr解决循环引用问题技巧

在C++中，

weak_ptr
是解决 
shared_ptr
循环引用导致内存泄漏问题的关键技巧。它提供了一种非拥有（non-owning）的引用机制，允许你观察一个由 
shared_ptr
管理的对象，而不会增加其引用计数。当所有 
shared_ptr
都释放了对对象的强引用后，即使仍有 
weak_ptr
指向它，对象也会被正确销毁，从而打破了循环引用的僵局。
#include <iostream>
#include <memory>
#include <vector>

class NodeA; // 前向声明

class NodeB {
public:
    std::shared_ptr<NodeA> parent; // 强引用，如果NodeA也强引用NodeB，就会形成循环

    NodeB() { std::cout << "NodeB 构造\n"; }
    ~NodeB() { std::cout << "NodeB 析构\n"; }

    void setParent(std::shared_ptr<NodeA> p) {
        parent = p;
    }
};

class NodeA {
public:
    std::weak_ptr<NodeB> child; // 使用 weak_ptr 解决循环引用

    NodeA() { std::cout << "NodeA 构造\n"; }
    ~NodeA() { std::cout << "NodeA 析构\n"; }

    void setChild(std::shared_ptr<NodeB> c) {
        child = c; // weak_ptr 不增加引用计数
    }

    void accessChild() {
        if (auto strongChild = child.lock()) { // 尝试获取 shared_ptr
            std::cout << "NodeA 成功访问到 NodeB 子节点。\n";
        } else {
            std::cout << "NodeA 尝试访问 NodeB 失败，子节点已销毁。\n";
        }
    }
};

// 模拟循环引用场景，并展示 weak_ptr 的解决方案
void demonstrate_circular_reference() {
    std::cout << "--- 演示 weak_ptr 解决循环引用 ---\n";
    std::shared_ptr<NodeA> nodeA_ptr = std::make_shared<NodeA>();
    std::shared_ptr<NodeB> nodeB_ptr = std::make_shared<NodeB>();

    std::cout << "初始化后: NodeA 引用计数 = " << nodeA_ptr.use_count()
              << ", NodeB 引用计数 = " << nodeB_ptr.use_count() << "\n";

    nodeA_ptr->setChild(nodeB_ptr); // NodeA 弱引用 NodeB
    nodeB_ptr->setParent(nodeA_ptr); // NodeB 强引用 NodeA

    std::cout << "设置引用后: NodeA 引用计数 = " << nodeA_ptr.use_count()
              << ", NodeB 引用计数 = " << nodeB_ptr.use_count() << "\n";

    nodeA_ptr->accessChild();

    // 当 nodeA_ptr 和 nodeB_ptr 超出作用域时
    // NodeB 的 parent 强引用 NodeA，NodeA 的引用计数为 1
    // NodeA 的 child 弱引用 NodeB，NodeB 的引用计数为 1
    // 由于 NodeB 的 parent 强引用 NodeA，NodeA 无法析构
    // 同样，NodeA 的 child 是弱引用，不影响 NodeB 析构
    // 但 NodeB 的强引用 NodeA 导致 NodeA 无法析构，进而导致 NodeB 也无法析构 (如果NodeA强引用NodeB，NodeB强引用NodeA)

    // 在这个例子中，NodeA 使用了 weak_ptr，所以 NodeB 的 parent 是唯一强引用 NodeA 的
    // 当 nodeA_ptr 超出作用域，NodeA 的引用计数会变为 1 (来自 NodeB 的 parent)
    // 当 nodeB_ptr 超出作用域，NodeB 的引用计数会变为 0，NodeB 析构
    // NodeB 析构时，其 parent (指向 NodeA) 的 shared_ptr 也被释放，NodeA 的引用计数变为 0，NodeA 析构。
    // 完美解决！
    std::cout << "shared_ptr 离开作用域...\n";
}

// int main() {
//     demonstrate_circular_reference();
//     std::cout << "--- 演示结束 ---\n";
//     return 0;
// }
shared_ptr
循环引用是如何产生的？为什么它会导致内存泄漏？

在我看来，

shared_ptr
的循环引用问题，其实是其设计哲学——“共享所有权”在特定场景下的一种“副作用”。它不是 
shared_ptr
的缺陷，而是我们使用时需要特别留心的一个边界情况。想象一下，当两个或多个对象通过 
shared_ptr
相互持有对方的强引用时，就形成了一个封闭的引用环。

具体来说，

shared_ptr
通过内部的引用计数器来管理对象的生命周期。每当一个新的 
shared_ptr
实例指向同一个对象时，引用计数加一；当一个 
shared_ptr
实例被销毁或重新赋值时，引用计数减一。只有当引用计数降到零时，它所管理的对象才会被自动释放。

循环引用发生时，例如对象A持有一个指向对象B的 

shared_ptr
，同时对象B也持有一个指向对象A的 
shared_ptr
。这时，即使所有外部指向A和B的 
shared_ptr
都已经失效（即离开了它们的作用域），A和B的内部引用计数却永远不会降到零。因为A的引用计数至少为1（来自B），B的引用计数也至少为1（来自A）。它们相互“锁定”了对方的生命周期，导致这两个对象及其内部资源永远无法被释放，这就是我们常说的内存泄漏。它们就像两个互相搀扶着走过生命尽头的老人，谁也不肯先放手，结果就是谁也无法安息。 
weak_ptr
在解决循环引用中的具体机制是什么？它和
shared_ptr
有什么不同？ 

weak_ptr
在我看来，是C++智能指针设计哲学的一个精妙体现，它提供了一种“旁观者”的角色。它不拥有对象，仅仅是观察着一个 
shared_ptr
所管理的对象。这种“观察”的关键在于，
weak_ptr
不会增加对象的引用计数。

它的具体机制在于：

  1. 不增加引用计数： 这是核心。当你用 
    shared_ptr
    初始化 
    weak_ptr
    ，或者将 
    shared_ptr
    赋值给 
    weak_ptr
    时，它不会像 
    shared_ptr
    那样增加对象的强引用计数。这意味着 
    weak_ptr
    的存在不会阻止对象被销毁。
  2. 安全性访问： 
    weak_ptr
    不能直接访问它所指向的对象。为了安全地使用对象，你必须先调用 
    weak_ptr::lock()
    方法。
    lock()
    会尝试将 
    weak_ptr
    提升为一个 
    shared_ptr
    。
    • 如果它所观察的对象仍然存在（即有至少一个 
      shared_ptr
      仍在管理该对象），
      lock()
      会成功返回一个指向该对象的 
      shared_ptr
      ，并且这个临时的 
      shared_ptr
      会增加对象的引用计数。
    • 如果它所观察的对象已经销毁（所有 
      shared_ptr
      都已释放），
      lock()
      会返回一个空的 
      shared_ptr
      （即 
      nullptr
      ）。
  3. 判断对象是否存活： 除了 
    lock()
    ，
    weak_ptr
    还有一个 
    expired()
    方法，可以用来判断它所观察的对象是否已经销毁。如果 
    expired()
    返回 
    true
    ，那么对象就已经不存在了。

weak_ptr
和 
shared_ptr
的根本区别在于所有权： PIA PIA

全面的AI聚合平台，一站式访问所有顶级AI模型

PIA226 查看详情 PIA 
  • shared_ptr
    ： 拥有对象，它通过引用计数共同管理对象的生命周期。只要有一个 
    shared_ptr
    存在，对象就不会被销毁。
  • weak_ptr
    ： 不拥有对象，它只是一个非拥有（non-owning）的观察者。它的存在不会影响对象的生命周期。它就像一个侦察兵，只负责汇报目标是否还在，但不参与目标的保卫战。

正是这种非拥有特性，使得 

weak_ptr
能够作为 
shared_ptr
循环引用中的“断路器”。在一个循环中，我们选择其中一个方向（通常是子节点指向父节点，或者观察者指向被观察者）使用 
weak_ptr
，这样就打破了强引用的闭环，允许对象在没有外部强引用时被正确析构。 在实际项目中，何时以及如何正确使用
weak_ptr
？有哪些常见的应用场景和注意事项？

在实际项目中，

weak_ptr
并非一个随处可见的工具，但当它出现时，往往是解决一些棘手所有权问题的关键。在我看来，它更像是一种“应急”或“特殊情况”下的解决方案，主要用于处理那些你明知道会有相互引用，但又不想因此造成内存泄漏的场景。

常见的应用场景：

  1. 父子关系中的子节点引用父节点： 这是一个非常经典的场景。比如，一个 
    Parent
    对象拥有多个 
    Child
    对象，
    Parent
    通过 
    shared_ptr
    管理 
    Child
    。为了让 
    Child
    能够访问它的 
    Parent
    ，如果 
    Child
    也用 
    shared_ptr
    引用 
    Parent
    ，就会形成循环。此时，让 
    Child
    持有 
    Parent
    的 
    weak_ptr
    是最佳选择。
    Child
    只需要知道它的 
    Parent
    是否还活着，并不需要延长 
    Parent
    的生命周期。
    class Parent;
class Child {
public:
    std::weak_ptr<Parent> parent; // 子节点弱引用父节点
    // ...
};
class Parent {
public:
    std::vector<std::shared_ptr<Child>> children; // 父节点强引用子节点
    // ...
};
  2. 观察者模式（Observer Pattern）： 在这种模式中，一个主题（Subject）对象被多个观察者（Observer）对象关注。当主题状态改变时，它会通知所有观察者。如果主题持有观察者的 
    shared_ptr
    ，而观察者又可能持有主题的 
    shared_ptr
    （例如，为了取消订阅），同样会形成循环。这时，主题应该持有观察者的 
    weak_ptr
    。这样，当观察者自身被销毁时，主题不会阻止它，并且在通知时可以安全地检查观察者是否仍然存在。
  3. 缓存机制： 在某些缓存实现中，缓存管理器可能需要存储对对象的引用。如果这些对象本身也可能引用缓存管理器，或者缓存管理器不希望延长被缓存对象的生命周期（希望在没有其他强引用时自动失效），那么使用 
    weak_ptr
    来存储缓存项的引用是一个很好的策略。
  4. 图结构中的回边或交叉边： 在复杂的图数据结构中，如果节点之间存在双向或多向连接，并且这些连接需要表示所有权，很容易陷入循环。通过策略性地使用 
    weak_ptr
    来表示那些不应延长对象生命周期的“次要”连接，可以有效地避免泄漏。

使用注意事项：

  1. 始终检查 
    lock()
    的返回值： 这是使用 
    weak_ptr
    最重要的规则。因为 
    weak_ptr
    所指向的对象可能随时被销毁，你必须在使用前通过 
    lock()
    方法获取一个 
    shared_ptr
    ，并检查它是否为空。如果为空，说明对象已经不存在了，不应再尝试访问。
    if (auto strong_ptr = weak_ptr_instance.lock()) {
    // 对象仍然存在，可以安全使用 strong_ptr
    strong_ptr->do_something();
} else {
    // 对象已销毁
    std::cout << "对象已销毁，无法访问。\n";
}
  2. 性能开销： 
    lock()
    操作涉及到对引用计数的原子操作，这会有轻微的性能开销。虽然通常可以忽略不计，但在对性能极其敏感的循环中频繁调用 
    lock()
    可能需要斟酌。
  3. 生命周期管理： 
    weak_ptr
    仅仅是观察者，它不参与对象的生命周期管理。这意味着，如果一个对象只被 
    weak_ptr
    引用，它仍然会被销毁。所以，确保至少有一个 
    shared_ptr
    在管理对象，以保证其存活是你希望的。
  4. 选择 
    weak_ptr
    还是裸指针： 在某些场景下，你可能只需要一个非拥有、非安全的引用，比如一个临时指针。这时裸指针可能更合适。
    weak_ptr
    的优势在于其安全性：即使对象被销毁，
    lock()
    也会返回 
    nullptr
    ，避免了悬空指针的风险。但这种安全性是有代价的（额外的存储和 
    lock()
    开销）。选择取决于你的具体需求：是需要安全的观察者，还是仅仅一个临时的、不承担任何所有权且不关心对象是否存活的指针。
  5. 避免过度使用： 
    weak_ptr
    是解决特定问题的工具，不是 
    shared_ptr
    的替代品。只有当你明确需要打破循环引用，或者需要一个不影响对象生命周期的观察者时，才应该考虑使用它。过度使用 
    weak_ptr
    会增加代码的复杂性，并引入更多的 
    lock()
    检查，反而可能降低可读性。

在我看来，

weak_ptr
的引入，让 
shared_ptr
的所有权模型变得更加灵活和健壮。它承认了现实世界中对象关系的多样性，有些关系是强烈的、拥有性的，而有些则只是短暂的、观察性的。掌握 
weak_ptr
的使用，是成为一个熟练的C++智能指针使用者的重要一步。

以上就是C++weak_ptr解决循环引用问题技巧的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： c++ node access 工具 ai ios 区别 作用域 为什么 red 循环 指针 数据结构 空指针 对象 作用域 大家都在看： C++如何使用模板实现迭代器类 C++如何处理复合对象中的嵌套元素 C++内存模型与编译器优化理解 C++如何使用ofstream和ifstream组合操作文件 C++循环与算法优化提高程序执行效率

标签:  循环 引用 解决 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

标签列表