C++weak_ptr解决循环引用问题技巧-C++-PHP中文网

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）。它们相互“锁定”了对方的生命周期，导致这两个对象及其内部资源永远无法被释放，这就是我们常说的内存泄漏。它们就像两个互相搀扶着走过生命尽头的老人，谁也不肯先放手，结果就是谁也无法安息。

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

weak_ptr

登录后复制

在解决循环引用中的具体机制是什么？它和

shared_ptr

登录后复制

有什么不同？

weak_ptr

登录后复制

在我看来，是C++智能指针设计哲学的一个精妙体现，它提供了一种“旁观者”的角色。它不拥有对象，仅仅是观察着一个

shared_ptr

登录后复制

所管理的对象。这种“观察”的关键在于，

weak_ptr

登录后复制

不会增加对象的引用计数。

它的具体机制在于：

AI建筑知识问答

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

查看详情

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

weak_ptr

登录后复制

和

shared_ptr

登录后复制

的根本区别在于所有权：

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

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

weak_ptr

登录后复制

能够作为

shared_ptr

登录后复制

循环引用中的“断路器”。在一个循环中，我们选择其中一个方向（通常是子节点指向父节点，或者观察者指向被观察者）使用

weak_ptr

登录后复制

，这样就打破了强引用的闭环，允许对象在没有外部强引用时被正确析构。

在实际项目中，何时以及如何正确使用

weak_ptr

登录后复制

？有哪些常见的应用场景和注意事项？

在实际项目中，

weak_ptr

登录后复制

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

常见的应用场景：

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

使用注意事项：

始终检查
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";
}
```
登录后复制
性能开销：
```
lock()
```
登录后复制
操作涉及到对引用计数的原子操作，这会有轻微的性能开销。虽然通常可以忽略不计，但在对性能极其敏感的循环中频繁调用
```
lock()
```
登录后复制
可能需要斟酌。
生命周期管理：
```
weak_ptr
```
登录后复制
仅仅是观察者，它不参与对象的生命周期管理。这意味着，如果一个对象只被
```
weak_ptr
```
登录后复制
引用，它仍然会被销毁。所以，确保至少有一个
```
shared_ptr
```
登录后复制
在管理对象，以保证其存活是你希望的。
选择
weak_ptr
登录后复制
还是裸指针：在某些场景下，你可能只需要一个非拥有、非安全的引用，比如一个临时指针。这时裸指针可能更合适。
```
weak_ptr
```
登录后复制
的优势在于其安全性：即使对象被销毁，
```
lock()
```
登录后复制
也会返回
```
nullptr
```
登录后复制
，避免了悬空指针的风险。但这种安全性是有代价的（额外的存储和
```
lock()
```
登录后复制
开销）。选择取决于你的具体需求：是需要安全的观察者，还是仅仅一个临时的、不承担任何所有权且不关心对象是否存活的指针。
避免过度使用：
```
weak_ptr
```
登录后复制
是解决特定问题的工具，不是
```
shared_ptr
```
登录后复制
的替代品。只有当你明确需要打破循环引用，或者需要一个不影响对象生命周期的观察者时，才应该考虑使用它。过度使用
```
weak_ptr
```
登录后复制
会增加代码的复杂性，并引入更多的
```
lock()
```
登录后复制
检查，反而可能降低可读性。