C++ 智能指针完整详解

使用场景

✅ 优先使用 unique_ptr，这是 C++ 官方推荐的首选智能指针，满足 90% 的场景：

• 所有「独占内存」的场景（一个对象只被一个指针管理）；
• 函数的返回值（返回动态对象，所有权转移给调用方）；
• 类的成员变量（持有类的私有资源，避免拷贝）；
• 容器存储（比如 vector<unique_ptr<int>>，利用移动语义存储）。

2. std::shared_ptr「共享型智能指针」—— 共享所有权场景必备

核心特性

shared_ptr 是共享所有权的智能指针：一块动态内存，可以被多个 shared_ptr 共同指向，所有指针共享同一块内存的所有权。

• 它是 C++11 新增的，底层通过引用计数（reference count）实现；
• 支持指向单个对象，C++17 开始原生支持数组（shared_ptr<int[]>）；
• 支持自定义删除器，支持拷贝、赋值，使用灵活。

核心原理：引用计数

shared_ptr 内部维护一个引用计数器，记录当前有多少个 shared_ptr 指向同一块内存：

1. 当新的 shared_ptr 指向该内存（拷贝、赋值），计数器 +1；
2. 当某个 shared_ptr 生命周期结束（出作用域、reset），计数器 -1；
3. 当计数器变为 0 时（没有任何指针指向这块内存了），自动调用 delete 释放内存。

关键规则

• ✅ 允许拷贝：shared_ptr<int> p2 = p1; 合法，计数器 +1；
• ✅ 允许赋值：p2 = p1; 合法，p2 原内存的计数器 -1，p1 内存的计数器 +1；
• ✅ 可以通过 use_count() 查看当前引用计数；
• ✅ 可以通过 unique() 判断是否是唯一持有者（计数器=1）。

常用示例

#include <memory>
#include <iostream>
using namespace std;

int main() {
    // 方式 1：创建 shared_ptr（推荐 make_shared，C++11 支持，效率更高）
    shared_ptr<int> p1 = make_shared<int>(20);
    cout << *p1 << endl; // 输出：20
    cout << p1.use_count() << endl; // 输出：1（只有 p1 指向内存）

    // 拷贝：计数器 +1
    shared_ptr<int> p2 = p1;
    cout << p2.use_count() << endl; // 输出：2（p1、p2 都指向内存）

    // 赋值：计数器变化
    shared_ptr<int> p3;
    p3 = p2;
    cout << p3.use_count() << endl; // 输出：3

    // 手动减少引用计数
    p1.reset();
    cout << p3.use_count() << endl; // 输出：2（p1 释放，计数器 -1）

    return 0; // 函数结束，p2、p3 生命周期结束，计数器减到 0，内存释放
}

使用场景

✅ 适用于多个地方需要共享同一个对象的场景：

• 多个函数、多个对象、多个容器需要访问同一块内存；
• 容器存储（vector<shared_ptr<int>>），支持自由拷贝和遍历；
• 类之间的关联关系（比如多个子对象指向同一个父对象）。

⚠️ 致命缺陷：循环引用（内存泄漏）

这是 shared_ptr 唯一的坑，也是高频面试题：

循环引用：两个（或多个）shared_ptr 互相指向对方，导致它们的引用计数器永远无法减到 0，最终内存泄漏。

典型场景：双向链表的节点、父子对象互相持有对方的 shared_ptr。

// 循环引用示例：内存泄漏！
struct Node {
    int val;
    shared_ptr<Node> next; // 节点指向另一个节点
};

int main() {
    shared_ptr<Node> n1 = make_shared<Node>();
    shared_ptr<Node> n2 = make_shared<Node>();
    n1->next = n2; // n1 持有 n2
    n2->next = n1; // n2 持有 n1
    // 函数结束时，n1 和 n2 的计数器都是 2，减到 1 后不再变化，内存永远不释放！
    return 0;
}

这个问题的唯一解决方案，就是下面的 std::weak_ptr。

3. std::weak_ptr「弱引用型智能指针」—— 仅用于解决 shared_ptr 的循环引用

核心定位

weak_ptr 是 C++11 新增的，辅助型智能指针，不能独立使用，必须配合 shared_ptr 一起使用！它不是一个真正的'智能指针'，而是 shared_ptr 的'补充工具'。

核心特性

weak_ptr 是弱引用：可以指向 shared_ptr 管理的内存，但不会增加引用计数，也不拥有内存的所有权。

• ❌ 没有重载 operator* 和 operator->，不能直接解引用访问内存；
• ❌ 不能单独创建，只能通过 shared_ptr 赋值/拷贝得到；
• ✅ 不会导致循环引用，因为它不增加引用计数；
• ✅ 可以检测自己指向的内存是否还存在（判活），避免访问野指针。

核心作用

✅ 唯一用途：解决 std::shared_ptr 的循环引用问题，没有其他场景需要使用 weak_ptr。

核心使用方法

1. 通过 shared_ptr 构造 weak_ptr：weak_ptr<int> wp = sp;（sp 是 shared_ptr）；
2. 要访问内存时，必须通过 wp.lock() 方法升级为 shared_ptr：
   • 如果内存还存在，lock() 返回一个有效的 shared_ptr，此时可以正常解引用；
   • 如果内存已释放，lock() 返回一个空的 shared_ptr，避免访问野指针；
3. 可以通过 wp.expired() 判断内存是否已释放（等价于 wp.lock() == nullptr）。

解决循环引用示例（关键修复）

struct Node {
    int val;
    weak_ptr<Node> next; // 把 shared_ptr 改为 weak_ptr，问题解决！
};

int main() {
    shared_ptr<Node> n1 = make_shared<Node>();
    shared_ptr<Node> n2 = make_shared<Node>();
    n1->next = n2; // weak_ptr 指向 n2，引用计数不增加
    n2->next = n1; // weak_ptr 指向 n1，引用计数不增加
    // 函数结束时，n1 和 n2 的计数器减到 0，内存正常释放！
    return 0;
}

4. std::auto_ptr「废弃的智能指针」—— 绝对不要使用！

基本背景

auto_ptr 是 C++98 标准中引入的第一个智能指针，也是 C++ 历史上的过渡产物。

核心问题（为什么被废弃）

auto_ptr 表面上是'独占型'智能指针，但它的拷贝/赋值语义存在严重缺陷：

• 它允许拷贝和赋值，但是拷贝/赋值后，原指针会被置为空指针，新指针持有内存；
• 这种'隐式转移所有权'的行为，会导致代码中出现不可预知的空指针访问，极易引发程序崩溃，是 C++ 中的'坑中之坑'。

废弃&移除标准

• C++11：标记为废弃，引入 unique_ptr 替代它，unique_ptr 从语法上禁止拷贝，彻底规避了这个问题；
• C++17：完全移除，标准库中不再提供 std::auto_ptr。

结论

✅ 记住：永远不要在任何 C++ 代码中使用 std::auto_ptr，无论是新项目还是老项目，都要替换为 std::unique_ptr。

三、补充：智能指针的创建方式（推荐写法）

所有智能指针都有两种创建方式，强烈推荐第一种：

方式 1：使用 make_xxx 函数（推荐，优先级最高）

• std::make_unique<T>(args)：创建 unique_ptr，C++14 支持；
• std::make_shared<T>(args)：创建 shared_ptr，C++11 支持。

优点：

1. 代码更简洁，无需手动写 new；
2. 内存分配更高效（make_shared 会一次性分配对象内存和引用计数内存）；
3. 避免内存泄漏（如果构造函数抛出异常，make_xxx 会自动释放已申请的内存）；
4. 避免裸指针暴露，更安全。

方式 2：通过裸指针构造（不推荐，应急使用）

// 应急写法，不推荐
unique_ptr<int> p1(new int(10));
shared_ptr<int> p2(new int(20));

缺点：如果构造过程中抛出异常，可能导致内存泄漏，且代码可读性差。

四、核心总结（必记，面试高频）

1. 智能指针核心价值

用 RAII 思想自动管理动态内存，彻底解决手动 new/delete 导致的内存泄漏问题。

2. 所有标准智能指针速览

3. 选型优先级（黄金法则）

能用 unique_ptr，就不用 shared_ptr；weak_ptr 只在解决循环引用时用

1. 优先选择 std::unique_ptr：轻量、高效、无坑，覆盖绝大多数场景；
2. 只有需要共享内存所有权时，才选择 std::shared_ptr；
3. 只有在 std::shared_ptr 出现循环引用时，才用 std::weak_ptr 修复；
4. 彻底忘掉 std::auto_ptr。

✨ 面试高频考点（补充）

1. 智能指针的实现原理？—— RAII 思想，构造持有资源，析构释放资源。
2. unique_ptr 和 shared_ptr 的区别？—— 独占 vs 共享，有无引用计数，效率差异。
3. shared_ptr 的坑是什么？怎么解决？—— 循环引用，用 weak_ptr 解决。
4. weak_ptr 为什么能解决循环引用？—— 弱引用不增加引用计数。
5. auto_ptr 为什么被废弃？—— 拷贝赋值会导致原指针为空，易崩溃。