<think>好的，用户现在想了解C++中的std::
weak_
ptr和shared_
ptr的使用方法。之前他们问过函数重写，现在转向智能指针，可能是在学习内存管理或准备项目。需要先理清两者的
基本概念和区别。
首先，用户可能知道shared_
ptr是用于共享所有权的智能指针，但
weak_
ptr的作用可能不太清楚。需要解释
weak_
ptr如何解决循环引用的问题，以及它的使用场景。
需要明确shared_
ptr通过引用计数管理资源，而
weak_
ptr不增加引用计数，只是观察资源。要举例说明循环引用的情况，比如两个类相互持有shared_
ptr，导致内存泄漏，这时候
weak_
ptr可以打破循环。
然后，具体的使用方法部分，分点说明shared_
ptr的创建、所有权共享、注意事项，比如避免裸指针初始化多个shared_
ptr。对于
weak_
ptr，要说明如何通过shared_
ptr创建，以及如何通过lock()获取临时shared_
ptr来访问资源。
可能用户需要知道如何正确使用
weak_
ptr，比如检查是否过期，以及何时使用。示例代码会有帮助，比如一个简单的类互相引用，展示如何用
weak_
ptr解决循环引用。
还要注意提及enable_shared_from_this，当类需要传递自身的shared_
ptr时使用，避免用this创建shared_
ptr导致的问题。
最后总结两者的使用场景和注意事项，确保用户理解何时使用哪种指针，以及常见错误如何避免。比如shared_
ptr用于共享所有权，
weak_
ptr用于观察但不拥有，避免循环引用导致的内存泄漏。
需要检查是否有遗漏点，比如make_shared的优势，控制块的结构，
weak_
ptr如何不影响引用计数，以及lock()的使用方法是否正确。确保回答结构清晰，步骤明确，示例易懂，帮助用户逐步理解两者的
用法和区别。</think>在C++中，`std::shared_
ptr` 和 `std::
weak_
ptr` 是智能指针的核心组件，用于自动管理动态内存的生命周期。以下是它们的核心
用法和区别：
---
### **1. `std::shared_
ptr`（共享所有权）**
#### **用途**
- 多个指针共享同一块内存的所有权。
- 内存的释放由最后一个持有该内存的 `shared_
ptr` 负责。
#### **核心方法**
```cpp
#include <memory>
// 创建方式
auto sp1 = std::make_shared<int>(42); // 推荐：高效且安全
std::shared_
ptr<int> sp2(new int(42)); // 直接初始化
std::shared_
ptr<int> sp3 = sp1; // 复制构造（引用计数+1）
// 使用
*sp1 = 100; // 解引用操作
sp1.reset(); // 手动释放所有权（引用计数-1）
if (sp1) { /* 检查是否为空 */ }
```
#### **引用计数机制**
- 每个 `shared_
ptr` 内部维护一个 **控制块**，记录引用计数和内存地址。
- 当引用计数归零时，自动调用 `delete` 释放内存。
- 示例：
```cpp
auto a = std::make_shared<int>(10); // 引用计数=1
auto b = a; // 引用计数=2
b.reset(); // 引用计数=1
a.reset(); // 引用计数=0，内存释放
```
#### **注意事项**
- **避免循环引用**：两个 `shared_
ptr` 相互持有会导致内存泄漏（需用 `
weak_
ptr` 解决）。
- **不要用裸指针初始化多个 `shared_
ptr`**：会导致多次释放内存。
```cpp
int* raw_
ptr = new int(10);
std::shared_
ptr<int> p1(raw_
ptr);
std::shared_
ptr<int> p2(raw_
ptr); // 错误！会重复释放内存
```
---
### **2. `std::
weak_
ptr`（观察所有权，不持有资源）**
#### **用途**
- 解决 `shared_
ptr` 的循环引用问题。
- 观察 `shared_
ptr` 管理的资源，但不增加引用计数。
#### **核心方法**
```cpp
// 从 shared_
ptr 创建
weak_
ptr
auto sp = std::make_shared<int>(42);
std::
weak_
ptr<int> wp(sp);
// 检查资源是否存在
if (auto locked = wp.lock()) { // 尝试获取 shared_
ptr
*locked = 100; // 使用资源
} else {
// 资源已被释放
}
```
#### **关键特性**
- **不控制生命周期**：`
weak_
ptr` 的创建和销毁不会影响引用计数。
- **必须通过 `lock()` 获取临时 `shared_
ptr`** 才能访问资源。
- 示例（解决循环引用）：
```cpp
class B;
class A {
public:
std::shared_
ptr<B> b_
ptr;
~A() { std::cout << "A destroyed\n"; }
};
class B {
public:
std::
weak_
ptr<A> a_
weak_
ptr; // 使用
weak_
ptr 替代 shared_
ptr
~B() { std::cout << "B destroyed\n"; }
};
int main() {
auto a = std::make_shared<A>();
auto b = std::make_shared<B>();
a->b_
ptr = b;
b->a_
weak_
ptr = a; // 不会增加 A 的引用计数
// a 和 b 的引用计数最终会归零，内存正确释放
}
```
---
### **3. 对比总结**
| 特性 | `shared_
ptr` | `
weak_
ptr` |
|---------------------|-----------------------------------|-----------------------------------|
| **所有权** | 共享所有权 | 无所有权，仅观察 |
| **引用计数** | 增加引用计数 | 不增加引用计数 |
| **资源访问** | 直接通过 `operator*` 或 `->` | 必须通过 `lock()` 获取临时 `shared_
ptr` |
| **典型场景** | 共享动态资源 | 打破循环引用、缓存、观察者模式 |
| **内存释放时机** | 引用计数归零时释放 | 不参与内存释放 |
---
### **4. 最佳实践**
1. **优先使用 `make_shared`**：避免显式 `new`，减少内存碎片和控制块分离。
2. **循环引用必须用 `
weak_
ptr`**：例如双向关联的类（如树节点、图形关系）。
3. **不要混合使用裸指针和智能指针**：
```cpp
auto sp = std::make_shared<int>(10);
int* raw = sp.get(); // 仅用于只读场景，切勿用 raw 初始化其他智能指针
```
4. **继承 `std::enable_shared_from_this`**：当类需要返回自身的 `shared_
ptr` 时。
```cpp
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
std::shared_
ptr<MyClass> get_self() {
return shared_from_this(); // 安全获取 this 的 shared_
ptr
}
};
```
---
### **示例：缓存系统**
```cpp
class Cache {
private:
std::unordered_map<int, std::
weak_
ptr<LargeData>> cache;
public:
std::shared_
ptr<LargeData> get(int id) {
auto it = cache.find(id);
if (it != cache.end()) {
auto sp = it->second.lock(); // 尝试获取数据
if (sp) return sp; // 数据仍存在，直接返回
}
// 数据不存在或已释放，重新加载
auto data = std::make_shared<LargeData>(load_data(id));
cache[id] = data; // 存储
weak_
ptr
return data;
}
};
```
通过 `shared_
ptr` 和 `
weak_
ptr` 的配合，可以高效实现资源的安全管理和复用。
扫一扫
4365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
