完整教程：C/C++内置库函数（2）：智能指针

一、std::unique_ptr（独占式智能指针）

1. 核心特性

• 独占所有权：同一时间只有一个 unique_ptr 指向某个对象，不可拷贝（copy），仅可移动（move）；
• 轻量级（无额外引用计数开销），效率接近裸指针；
• 适用场景：单个所有者管理对象（如函数返回值、局部动态对象、容器元素）。

2. 定义方式：

定义形式	说明
unique_ptr<T> ptr;	定义空的 unique_ptr（不指向任何对象）
unique_ptr<T> ptr(已有裸指针);	该裸指针必须是由new分配的，否则delete的时候报错
unique_ptr<T> ptr(new T); std::unique_ptr<T[]> ptr(new T[N]);	绑定到动态分配的 T 类型对象（C++11 基础方式）
auto ptr = make_unique<T>(args); 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(已有裸指针);	接管已存在的动态裸指针
shared_ptr<T> ptr(new T); std::shared_ptr<T[]> ptr(new T[N]);	绑定动态对象（不推荐，存在内存泄漏风险）
auto ptr = make_shared<T>(args); 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_shared
    std::shared_ptr ptr1 = std::make_shared(100);
    std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 1
    // 2. 拷贝：引用计数 +1
    std::shared_ptr ptr2 = ptr1;
    std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 2
    // 3. 赋值：ptr3 接管，引用计数 +1
    std::shared_ptr ptr3;
    ptr3 = ptr2;
    std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 3
    // 4. 重置：ptr3 释放所有权，引用计数 -1
    ptr3.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 自身的资源，不影响被观察对象