全面理解-c++11中的智能指针

在 C++ 中，智能指针（Smart Pointers） 是用于自动管理动态分配内存的类模板，遵循 RAII（Resource Acquisition Is Initialization） 原则，确保资源在生命周期结束时被正确释放，避免内存泄漏。C++11 引入了三种主要的智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr，取代了 C++98 中不安全的 std::auto_ptr。

1. 为什么需要智能指针？

手动管理内存的痛点：
- 忘记 delete 导致内存泄漏。
- 重复 delete 导致未定义行为。
- 异常安全问题（未捕获异常时资源无法释放）。
智能指针的核心作用：
- 自动释放内存：对象生命周期结束时自动调用 delete。
- 明确所有权语义：通过所有权模型管理资源。

2. 主要智能指针类型

(1) `std::unique_ptr`（独占所有权）

所有权模型：唯一拥有资源，不可复制，但可通过 std::move 转移所有权。
适用场景：
- 资源有唯一拥有者。
- 需要轻量级、零开销的内存管理。

基本用法：

#include <memory>// 创建 unique_ptr
std::unique_ptr<int> ptr1 = std::make_unique<int>(10);  // C++14 起推荐
std::unique_ptr<int> ptr2(new int(20));                 // 直接构造// 转移所有权
std::unique_ptr<int> ptr3 = std::move(ptr1);  // ptr1 变为 nullptr// 自定义删除器（可选）
auto deleter = [](int* p) { delete p; };
std::unique_ptr<int, decltype(deleter)> ptr4(new int(30), deleter);

(2) `std::shared_ptr`（共享所有权）

所有权模型：通过引用计数（use_count()）管理资源，多个指针共享所有权。
适用场景：
- 多个对象需要共享同一资源。
- 资源生命周期不确定，需自动管理。

基本用法：

// 创建 shared_ptr
std::shared_ptr<int> ptr1 = std::make_shared<int>(10);  // 推荐（高效）
std::shared_ptr<int> ptr2(new int(20));                 // 直接构造// 共享所有权
std::shared_ptr<int> ptr3 = ptr1;  // 引用计数 +1（ptr1.use_count() == 2）// 自定义删除器（可选）
std::shared_ptr<int> ptr4(new int(30), [](int* p) { delete p; });

(3) `std::weak_ptr`（弱引用）

所有权模型：不增加引用计数，用于解决 shared_ptr 的循环引用问题。
适用场景：
- 观察 shared_ptr 管理的资源，不参与所有权管理。
- 打破 shared_ptr 的循环引用（如双向链表、观察者模式）。

基本用法：

std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
std::weak_ptr<int> weakPtr = sharedPtr;// 使用时提升为 shared_ptr
if (auto tempPtr = weakPtr.lock()) {  // 检查资源是否有效std::cout << *tempPtr << std::endl;  // 输出 42
}

(4) `std::auto_ptr`（已弃用）

问题：所有权转移语义不明确（通过拷贝构造函数转移所有权），易导致悬空指针。
替代方案：使用 std::unique_ptr。

3. 智能指针的核心对比

特性	`std::unique_ptr`	`std::shared_ptr`	`std::weak_ptr`
所有权	独占	共享	无（弱引用）
拷贝语义	禁止（只能移动）	允许（引用计数增加）	允许（不增加引用计数）
性能开销	无	引用计数操作（原子操作）	无
循环引用处理	不适用	无法解决	可解决
自定义删除器	支持（模板参数）	支持（构造函数参数）	不适用

4. 使用建议

优先使用 std::make_unique 和 std::make_shared：
- 更高效（减少内存分配次数）。
- 异常安全。
```
auto ptr = std::make_shared<int>(42);  // 替代 new
```

避免裸指针与智能指针混用：

int* rawPtr = new int(10);
std::shared_ptr<int> ptr(rawPtr);  // ❌ 危险：多个 shared_ptr 可能管理同一裸指针

解决循环引用：

使用 std::weak_ptr 断开 shared_ptr 的循环依赖。

class B;  // 前向声明class A {
public:std::shared_ptr<B> bPtr;
};class B {
public:std::weak_ptr<A> aPtr;  // 使用 weak_ptr 代替 shared_ptr
};

传递智能指针的规则：
- 函数参数：
  - 如果函数需要接管所有权 → 按值传递 std::unique_ptr。
  - 如果函数只是使用资源 → 传递裸指针或引用。
```
void takeOwnership(std::unique_ptr<int> ptr);  // 接管所有权
void useResource(const int* ptr);              // 仅使用资源
```

5. 智能指针的底层原理

std::unique_ptr：
- 内部封装一个裸指针，删除时调用 delete 或自定义删除器。
- 禁止拷贝构造函数和拷贝赋值运算符。
std::shared_ptr：
- 包含两个指针：一个指向对象，一个指向控制块（含引用计数和删除器）。
- 引用计数为 0 时释放资源。
std::weak_ptr：
- 不增加引用计数，但能检测资源是否有效。

6. 示例代码

(1) `unique_ptr` 管理动态数组

// 管理动态数组（C++11 需要指定删除器，C++14 起可直接用 unique_ptr<T[]>）
std::unique_ptr<int[]> arr(new int[5]{1, 2, 3, 4, 5});
arr[0] = 10;

(2) `shared_ptr` 的循环引用问题

#include <memory>class Node {
public:std::shared_ptr<Node> next;
};int main() {auto node1 = std::make_shared<Node>();auto node2 = std::make_shared<Node>();node1->next = node2;  // node1 引用 node2node2->next = node1;  // node2 引用 node1 → 循环引用，内存泄漏！return 0;
}

解决方案：将其中一个 shared_ptr 替换为 weak_ptr。