<think>
我们正在解决用户的问题：如何在C++中
使用weak_
ptr解决
shared_
ptr的
循环引用问题？
根据
引用[1][2][3][5]中的内容，
循环引用问题发生在两个或多个对象互相持有对方的
shared_
ptr，导致
引用计数永远不为0，从而内存泄漏。
解决方案：将其中一个指针改为
weak_
ptr，因为
weak_
ptr不会增加
引用计数，从而
打破循环。
步骤：
1. 识别
循环引用：两个类A和B，A持有B的
shared_
ptr，B持有A的
shared_
ptr。
2. 将其中一个指针改为
weak_
ptr（通常根据所有权关系决定，谁拥有谁，谁就
使用shared_
ptr；谁只是观察，谁就
使用weak_
ptr）。
3. 通过
weak_
ptr的lock()方法获取
shared_
ptr来临时
使用对象（注意：
使用前需检查获取的
shared_
ptr是否为空，因为对象可能已被释放）。
示例代码（修改自
引用[5]）：
原
循环引用代码导致A和B的析构函数不被调用：
class A { public:
shared_
ptr<B> b
ptr; ... };
class B { public:
shared_
ptr<A> a
ptr; ... };
test()中：ap
->b
ptr = bp; bp
->a
ptr = ap; //
循环引用，
引用计数为2，离开作用域后计数减为1，内存泄漏。
修改后：将其中一个指针改为
weak_
ptr，例如将类A中指向B的指针改为
weak_
ptr：
class A { public:
weak_
ptr<B> b
ptr; ... };
class B { public:
shared_
ptr<A> a
ptr; ... }; // 或者反过来，取决于设计。
注意：
weak_
ptr不能直接访问对象，必须通过lock()方法获取一个
shared_
ptr，并且在获取后检查其是否有效。
代码修改如下：
</think>
### 如何在 C++ 中
使用 weak_
ptr 解决
shared_
ptr 循环引用问题
循环引用问题发生在两个或多个对象通过 `
shared_
ptr` 互相持有对方时，导致
引用计数无法归零，从而引发内存泄漏。`
weak_
ptr` 作为解决方案，通过不增加
引用计数来
打破循环依赖。以下是具体方法和步骤：
#### 🔄
循环引用示例（问题重现）
```cpp
#include <memory>
class B;
class A {
public:
std::
shared_
ptr<B> b_
ptr; // 持有 B 的
shared_
ptr
~A() { std::cout << "A destroyed\n"; }
};
class B {
public:
std::
shared_
ptr<A> a_
ptr; // 持有 A 的
shared_
ptr
~B() { std::cout << "B destroyed\n"; }
};
void test() {
auto a = std::make_
shared<A>(); // a 的
引用计数=1
auto b = std::make_
shared<B>(); // b 的
引用计数=1
a
->b_
ptr = b; // b 的
引用计数=2
b
->a_
ptr = a; // a 的
引用计数=2
} // 离开作用域：a 计数减至1, b 计数减至1 → 内存泄漏！
```
执行后无析构输出，证明对象未释放[^5]。
#### ⚙️
使用 weak_
ptr 的解决方案
1. **将其中一个 `
shared_
ptr` 改为 `
weak_
ptr`**
```cpp
class B; // 前置声明
class A {
public:
std::
shared_
ptr<B> b_
ptr; // 保持
shared_
ptr
~A() { std::cout << "A destroyed\n"; }
};
class B {
public:
std::
weak_
ptr<A> a_
ptr; // 改为
weak_
ptr（不增加计数）
~B() { std::cout << "B destroyed\n"; }
};
```
2. **访问对象时通过 `lock()` 安全升级**
```cpp
void use_object(B& obj) {
if (auto spt = obj.a_
ptr.lock()) { // 尝试升级为
shared_
ptr
std::cout << "Access A object successfully\n";
// 安全
使用 spt 指向的 A 对象
} else {
std::cout << "A object already destroyed\n";
}
}
```
#### ✅ 解决后的效果
```cpp
void test_fixed() {
auto a = std::make_
shared<A>(); // a 计数=1
auto b = std::make_
shared<B>(); // b 计数=1
a
->b_
ptr = b; // b 计数=2
b
->a_
ptr = a; // a 计数仍为1（
weak_
ptr 不增加计数）
} // 离开作用域：
// a 计数归零 → 销毁 A → 释放 b_
ptr（b 计数减至1）
// b 计数归零 → 销毁 B
```
输出结果：
```
A destroyed
B destroyed
```
#### 📝 关键机制说明
1. **`
weak_
ptr` 不增加
引用计数**
仅作为观察者存在，不影响对象生命周期[^2]。
2. **`lock()` 方法的安全访问**
- 返回一个临时 `
shared_
ptr`，在其作用域内保证对象存活
- 若原对象已销毁，返回空指针[^3]
3. **生命周期管理**
`
weak_
ptr` 析构时不会触发资源释放，仅当最后一个 `
shared_
ptr` 释放时才销毁资源[^1]。
#### 💡 最佳实践
1. **所有权设计原则**
- 明确核心所有权关系：持有实际所有权的对象用 `
shared_
ptr`
- 从属关系或观察者用 `
weak_
ptr`（如示例中 `B` 观察 `A`）
2. **避免裸指针转换**
不要用 `
weak_
ptr::get()` 获取裸指针，因其无法保证对象有效性：
```cpp
// 错误做法（不安全）：
A* raw_
ptr = b.a_
ptr.get(); // 对象可能已被释放
// 正确做法（安全）：
if (auto spt = b.a_
ptr.lock()) { /*
使用 spt */ }
```
3. **
循环引用检测**
若对象未按预期析构，检查是否存在未
打破的 `
shared_
ptr` 闭环[^4]。
> **总结**：`
weak_
ptr` 通过不参与
引用计数的特性，切断 `
shared_
ptr` 的
循环引用链。
使用时需配合 `lock()` 安全访问对象，并在设计阶段明确所有权关系以避免内存泄漏[^1][^2][^3][^5]。
---
### 相关问题
1. **`
weak_
ptr` 的 `lock()` 方法在什么情况下返回空指针？如何避免访问失效对象？**
2. **在多线程环境中
使用 `
weak_
ptr` 需要注意哪些线程安全问题？**
3. **如何通过自定义删除器扩展 `
shared_
ptr` 的功能？**
4. **在哪些场景下应该优先选择 `unique_
ptr` 而非 `
shared_
ptr`？**
本文通过一个C++代码示例展示了如何使用boost::weak_ptr来解决智能指针之间的循环引用问题。在示例中，两个结构体A和B互相持有对方的智能指针，使用weak_ptr可以避免这种循环导致的内存泄漏。
扫一扫
3万+
到【灌水乐园】发言
