完整教程：C/C++内置库函数（2）：智能指针
一、std::unique_ptr（独占式智能指针）
1. 核心特性
- 独占所有权：同一时间只有一个
unique_ptr指向某个对象，不可拷贝（copy），仅可移动（move）； - 轻量级（无额外引用计数开销），效率接近裸指针；
- 适用场景：单个所有者管理对象（如函数返回值、局部动态对象、容器元素）。
2. 定义方式：
| 定义形式 | 说明 |
|---|---|
unique_ptr<T> ptr; | 定义空的 unique_ptr（不指向任何对象） |
| unique_ptr<T> ptr(已有裸指针); | 该裸指针必须是由new分配的，否则delete的时候报错 |
std::unique_ptr<T[]> ptr(new T[N]); | 绑定到动态分配的 T 类型对象（C++11 基础方式） |
auto ptr = std::make_unique<T[]>(N); | C++14 推荐方式（更安全，避免内存泄漏），args 是 T 的构造参数 |
3. 常用方法
| 方法 | 功能 |
|---|---|
ptr.get() | 返回管理的裸指针（仅临时使用，避免长期持有） |
ptr.release() | 释放所有权（返回裸指针，不会释放内存，需手动处理） |
ptr.reset() | 释放当前对象内存，重置为空；reset(new T) 则释放旧对象，指向新对象 |
ptr.swap() | 交换两个 unique_ptr 管理的对象 |
operator* | 解引用，访问指向的对象（如 *ptr = 10;） |
operator-> | 访问对象的成员（如 ptr->func();） |
#include
#include // 必须包含
// 自定义类示例
class Test {
public:Test(int v) : val(v) { std::cout << "Test 构造：" << val << "\n"; }~Test() { std::cout << "Test 析构：" << val << "\n"; }void show() { std::cout << "值：" << val << "\n"; }
private:int val;
};
int main() {// 1. 定义并初始化（C++11 方式）std::unique_ptr ptr1(new Test(10));ptr1->show(); // 访问成员函数// 2. C++14 推荐：make_unique（更安全，避免内存泄漏）auto ptr2 = std::make_unique(20);(*ptr2).show(); // 解引用访问// 3. 移动语义（唯一的“拷贝”方式）std::unique_ptr ptr3 = std::move(ptr1); // ptr1 变为空，ptr3 接管if (!ptr1) std::cout << "ptr1 已空\n";ptr3->show();// 4. 重置（释放旧对象，指向新对象）ptr3.reset(new Test(30)); // 旧对象（val=10）析构，指向 val=30 的新对象// 5. 释放所有权（返回裸指针，需手动 delete）Test* raw_ptr = ptr3.release();delete raw_ptr; // 必须手动释放，否则内存泄漏return 0; // 作用域结束，ptr2 自动析构（val=20 释放）
} 二、std::shared_ptr（共享式智能指针）
1. 核心特性
- 共享所有权：多个
shared_ptr可指向同一对象，通过引用计数管理； - 引用计数为 0 时，自动释放对象内存；
- 可拷贝、可赋值，拷贝时引用计数 +1，析构 / 重置时引用计数 -1；
- 适用场景：多个所有者共享同一对象（如容器、多线程共享资源）
2. 定义方式：
| 定义形式 | 说明 |
|---|---|
shared_ptr<T> ptr; | 空的 shared_ptr |
std::shared_ptr<T> ptr(已有裸指针); | 接管已存在的动态裸指针 |
std::shared_ptr<T[]> ptr(new T[N]); | 绑定动态对象（不推荐，存在内存泄漏风险） |
auto ptr = std::make_shared<T[]>(N); | 推荐方式（更高效，内存分配一次，避免泄漏） |
3. 常用方法
| 方法 | 功能 |
|---|---|
ptr.use_count() | 返回当前引用计数（调试用） |
ptr.unique() | 判断是否为唯一所有者（引用计数 == 1 时返回 true） |
ptr.reset() | 释放当前对象的所有权（引用计数 -1），重置为空 |
ptr.lock() | （weak_ptr 方法）尝试获取可用的 shared_ptr（非 expired 时有效） |
ptr.expired() | （weak_ptr 方法）判断所指对象是否已释放（引用计数 == 0） |
| （继承 unique_ptr） | get()、operator*、operator-> 等 |
#include
#include
class Test {
public:Test(int v) : val(v) { std::cout << "Test 构造：" << val << "\n"; }~Test() { std::cout << "Test 析构：" << val << "\n"; }int val;
};
int main() {// 1. 推荐方式：make_sharedstd::shared_ptr ptr1 = std::make_shared(100);std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 1// 2. 拷贝：引用计数 +1std::shared_ptr ptr2 = ptr1;std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 2// 3. 赋值：ptr3 接管，引用计数 +1std::shared_ptr ptr3;ptr3 = ptr2;std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 3// 4. 重置：ptr3 释放所有权，引用计数 -1ptr3.reset();std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 2// 5. 唯一所有者判断ptr2.reset();std::cout << "是否唯一：" << ptr1.unique() << "\n"; // 输出 1（true）return 0; // ptr1 析构，引用计数 0，对象释放
} 三、std::weak_ptr（弱引用智能指针）
1. 核心特性
- 弱引用：指向
shared_ptr管理的对象，但不增加引用计数； - 不拥有对象所有权，仅作为 “观察者”，避免
shared_ptr的循环引用问题； - 无法直接访问对象，需通过
lock()方法转为shared_ptr后使用。
2. 定义方式：
| 定义形式 | 说明 |
|---|---|
std::weak_ptr<T> ptr; | 空初始化：ptr 不观察任何对象，expired() 返回 true |
std::weak_ptr<T> ptr(shared_ptr对象); | 观察 shared_ptr 管理的对象，引用计数不变 |
#include
#include
// 循环引用问题场景
struct Node {// 错误：两个 shared_ptr 互相引用，引用计数永远不为 0，内存泄漏// std::shared_ptr next;// 正确：用 weak_ptr 避免增加引用计数std::weak_ptr next;~Node() { std::cout << "Node 析构\n"; }
};
int main() {std::shared_ptr node1 = std::make_shared();std::shared_ptr node2 = std::make_shared();// 互相引用node1->next = node2; // weak_ptr 赋值，node2 引用计数不变node2->next = node1; // weak_ptr 赋值，node1 引用计数不变// 尝试访问 weak_ptr 指向的对象（需 lock()）std::shared_ptr temp = node1->next.lock();if (temp) {std::cout << "node1->next 有效\n";}return 0; // node1、node2 析构，引用计数 0，对象释放
} 四、总结：
| 智能指针 | 所有权 | 拷贝性 | 引用计数 | 核心场景 |
|---|---|---|---|---|
| unique_ptr | 独占 | 不可拷贝，可移动 | 无 | 单个所有者、局部对象 |
| shared_ptr | 共享 | 可拷贝、可赋值 | 有 | 多所有者、共享资源 |
| weak_ptr | 无 | 可拷贝、可赋值 | 无 | 解决 shared_ptr 循环引用 |
1. 禁止的操作
- 不要将同一个裸指针赋值给多个
unique_ptr（会导致重复释放）； - 不要用
get()返回的裸指针手动delete（智能指针会重复释放）； - 避免
shared_ptr循环引用（用weak_ptr解决）； - 不要在多线程中直接修改
shared_ptr本身（引用计数操作线程安全，但对象访问需加锁）。
2. 最佳实践
| 场景 | 推荐智能指针 |
|---|---|
| 单个所有者管理对象 | unique_ptr |
| 多个所有者共享对象 | shared_ptr |
| 解决 shared_ptr 循环引用 | weak_ptr |
| 动态数组 | unique_ptr<T[]>（C++11）/ shared_ptr<T[]> |
| 函数返回动态对象 | unique_ptr（高效） |
五、智能指针别的定义方式：
1. unique_ptr
| 定义形式 | 说明 | 注意事项（版本 / 风险） |
|---|---|---|
std::unique_ptr<T> ptr; | 空初始化：ptr 不指向任何对象，ptr == nullptr | C++11+；默认删除器 std::default_delete<T> |
std::unique_ptr<T> ptr(nullptr); | 显式空初始化（等价于上一种） | C++11+；可读性更强 |
std::unique_ptr<T> ptr(new T); | 绑定新动态分配的单个 T 类型裸指针 | C++11+；裸指针必须是 new 分配，避免重复接管 |
std::unique_ptr<T> ptr(已有裸指针); | 接管已存在的动态裸指针（如函数返回的裸指针） | C++11+；裸指针必须是 new 分配，且仅能被一个 unique_ptr 接管 |
std::unique_ptr<T[]> ptr(new T[N]); | 绑定动态数组裸指针（数组版） | C++11+；自动调用 delete[]，支持下标访问 ptr[i] |
auto ptr = std::make_unique<T>(args...); | 直接创建单个 T 对象并初始化（推荐） | C++14+；更安全（避免内存泄漏），args 是 T 的构造参数 |
auto ptr = std::make_unique<T[]>(N); | 直接创建长度为 N 的 T 类型动态数组 | C++14+；数组元素默认初始化（如 int 数组值为 0） |
auto ptr = std::make_unique<T[]>({v1, v2, ...}); | 创建动态数组并初始化元素 | C++20+；仅支持固定初始值列表 |
std::unique_ptr<T> ptr(std::move(另一个unique_ptr)); | 移动初始化：接管另一个 unique_ptr 的所有权 | C++11+；原 unique_ptr 变为空，不可拷贝仅可移动 |
std::unique_ptr<T, Deleter> ptr(new T, 自定义删除器); | 自定义删除器：替换默认的 delete 逻辑 | C++11+；删除器需满足可调用，如 std::function<void(T*)> 或 lambda |
std::unique_ptr<T[], Deleter> ptr(new T[N], 自定义数组删除器); | 数组版 + 自定义删除器 | C++11+；删除器需适配数组（调用 delete[] 或自定义释放逻辑） |
std::unique_ptr<T> ptr(std::auto_ptr<T>(std::move(ap))); | 从废弃的 auto_ptr 转换（兼容用） | C++11+；auto_ptr 已废弃，仅用于老代码迁移 |
2. shared_ptr
| 定义形式 | 说明 | 注意事项（版本 / 风险） |
|---|---|---|
std::shared_ptr<T> ptr; | 空初始化：ptr 不指向任何对象，引用计数 0 | C++11+；默认删除器 std::default_delete<T> |
std::shared_ptr<T> ptr(nullptr); | 显式空初始化（等价于上一种） | C++11+；可读性更强 |
std::shared_ptr<T> ptr(new T); | 绑定新动态分配的单个 T 类型裸指针 | C++11+；不推荐（存在内存泄漏风险），优先用 make_shared |
std::shared_ptr<T> ptr(已有裸指针); | 接管已存在的动态裸指针 | C++11+；禁止将同一裸指针赋值给多个 shared_ptr（重复计数导致重复释放） |
std::shared_ptr<T> ptr(new T[N], std::default_delete<T[]>()); | 绑定动态数组（C++17 前需指定数组删除器） | C++11+；C++17 后可省略删除器，默认支持数组 |
std::shared_ptr<T[]> ptr(new T[N]); | 数组版初始化（默认删除器支持数组） | C++17+；支持下标访问 ptr[i] |
auto ptr = std::make_shared<T>(args...); | 直接创建单个 T 对象并初始化（推荐） | C++11+；内存分配更高效（一次分配对象 + 引用计数），args 是构造参数 |
auto ptr = std::make_shared<T[]>(N); | 直接创建长度为 N 的 T 类型动态数组 | C++20+；数组元素默认初始化 |
std::shared_ptr<T> ptr(std::move(另一个shared_ptr)); | 移动初始化：接管另一个 shared_ptr 的所有权，引用计数不变 | C++11+；原 shared_ptr 变为空 |
std::shared_ptr<T> ptr(另一个shared_ptr); | 拷贝初始化：共享所有权，引用计数 +1 | C++11+；可拷贝是 shared_ptr 核心特征 |
std::shared_ptr<T> ptr(new T, 自定义删除器); | 自定义删除器：替换默认的 delete 逻辑 | C++11+；删除器不影响 shared_ptr 类型（类型擦除） |
std::shared_ptr<T> ptr(std::unique_ptr<T>(std::move(up))); | 从 unique_ptr 转换：接管其所有权，引用计数设为 1 | C++11+；unique_ptr 必须移动，转换后变为空 |
std::shared_ptr<T> ptr(weak_ptr.lock()); | 从 weak_ptr 转换：若对象未释放则获取 shared_ptr，否则返回空 | C++11+；需先判断 ptr 是否为空（避免悬空） |
3. weak_ptr
| 定义形式 | 说明 | 注意事项（版本 / 风险） |
|---|---|---|
std::weak_ptr<T> ptr; | 空初始化：ptr 不观察任何对象，expired() 返回 true | C++11+；无引用计数，不拥有对象所有权 |
std::weak_ptr<T> ptr(nullptr); | 显式空初始化（等价于上一种） | C++11+；可读性更强 |
std::weak_ptr<T> ptr(shared_ptr对象); | 观察 shared_ptr 管理的对象，引用计数不变 | C++11+；核心用法（解决循环引用） |
std::weak_ptr<T> ptr(另一个weak_ptr); | 拷贝初始化：观察同一个对象 | C++11+；引用计数不变 |
std::weak_ptr<T> ptr(std::move(另一个weak_ptr)); | 移动初始化：观察同一个对象，原 weak_ptr 变为空 | C++11+；仅转移 weak_ptr 自身的资源，不影响被观察对象 |
