C++ 智能指针详解：unique_ptr、shared_ptr 与 weak_ptr 用法及避坑指南

什么是智能指针及其解决的问题

智能指针本质上是对普通指针的封装，其核心基于 RAII（Resource Acquisition Is Initialization，资源获取即初始化）机制。它将资源的生命周期与对象的作用域绑定：当封装对象的析构函数被调用时，会自动释放管理的内存。这使得程序员无需再关心何时手动调用 delete，从而有效避免内存泄漏和野指针问题。

在 C++11 标准中，定义了四种智能指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中 auto_ptr 因存在语义缺陷，已在 C++11 中被弃用，并在 C++17 中彻底移除。现代 C++ 开发应主要关注后三种。

第1步：理解原始指针的风险

在使用智能指针之前，需明确传统指针管理的痛点。以下是一段典型的资源分配代码：

objtype *p = new objtype();
p->func();
delete p;

该模式存在两大隐患：

1. 遗漏释放：若后续代码忘记执行 delete p，将导致内存泄漏。
2. 异常安全缺失：若 func() 内部抛出异常，程序流程跳转至 catch 块或终止，delete p 语句无法执行，同样引发泄漏。

智能指针通过析构函数的确定性调用解决了这一问题。只要对象构建成功，无论是否发生异常，其生命周期结束时的析构动作都会被触发。

unique_ptr：独占所有权的智能指针

unique_ptr 表示对托管对象的唯一所有权。它在编译期通过禁止拷贝构造函数和赋值运算符来确保同一时刻只有一个 unique_ptr 指向该对象。它主要用于替代原始指针，提供轻量级的自动内存管理。

第2步：正确创建与使用 unique_ptr

可通过构造函数或 std::make_unique（C++14起推荐）进行初始化：

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

void f1() {
    // 直接初始化
    unique_ptr<int> p(new int(5));
    cout << *p << endl;
}

关键限制：不支持普通拷贝。

void f1() {
    unique_ptr<int> p(new int(5));
    unique_ptr<int> p2(p);   // 编译错误！
    unique_ptr<int> p3 = p;  // 编译错误！
}

此时 IDE 通常会报错：“无法引用 ... unique_ptr(const unique_ptr &)” —— 因为该函数已被删除。

第3步：使用 move 转移所有权

虽然不能拷贝，但支持通过 std::move 显式转移所有权：

void f1() {
    unique_ptr<int> p(new int(5));
    unique_ptr<int> p2 = std::move(p);
    
    // 此时 p 为空 (nullptr)，访问 *p 将导致崩溃
    // cout << *p << endl; 
    cout << *p2 << endl; // 输出 5
}

shared_ptr：共享所有权的智能指针

当多个组件需要共同管理同一个资源时，应使用 shared_ptr。它通过原子操作维护一个引用计数器（Reference Count），记录有多少个 shared_ptr 实例指向该对象。仅当最后一个实例销毁时，才会真正释放内存。

第4步：创建与拷贝 shared_ptr

错误写法：直接用原始指针构造会导致引用计数逻辑混乱（通常视为只有一个所有者，但若其他地方也有原始指针则可能重复 delete）：

// 错误演示：不推荐这样写，应使用 make_shared
// shared_ptr<int> p4 = new int(1);

正确写法：推荐使用 std::make_shared，它可以一次性分配控制块和数据，性能更好且异常更安全：

void f2() {
    shared_ptr<int> p = make_shared<int>(1);
    shared_ptr<int> p2(p); // 拷贝，引用计数加1
    shared_ptr<int> p3 = p; // 拷贝，引用计数再加1
}

若需获取底层原始指针，可使用 .get() 方法，但请勿自行 delete 该指针：

void f2() {
    shared_ptr<int> p = make_shared<int>(1);
    int *p2 = p.get();
    cout << *p2 << endl; // 安全读取
}

shared_ptr 的核心陷阱：循环引用

shared_ptr 最大的风险在于“循环引用”。当两个对象相互持有对方的 shared_ptr 时，它们的引用计数永远不会降为 0，导致内存泄漏。

第5步：识别并解决循环引用

以下结构体现了典型的父子双向循环引用：

struct Father {
    shared_ptr<Son> son_;
};

struct Son {
    shared_ptr<Father> father_;
};

int main() {
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();
    
    father->son_ = son;
    son->father_ = father;
    
    return 0; // 此处发生内存泄漏
}

原因分析：

1. 退出 main 前，Father 和 Son 引用计数均为 2（本地变量 + 成员变量）。
2. son 变量销毁，Son 引用计数变为 1。
3. father 变量销毁，Father 引用计数变为 1。
4. 双方计数均不为 0，互不相让，内存无法释放。

解决方案：引入 weak_ptr。

weak_ptr 是一种非拥有性观察者。它不增加引用计数，因此不会参与析构决策。修改后的结构如下：

struct Father {
    shared_ptr<Son> son_; // 拥有权
};

struct Son {
    weak_ptr<Father> father_; // 弱引用，不增加计数
};

效果验证：

1. 退出 main 前，Son 引用计数为 2（son 变量 + father 的成员），Father 引用计数为 1（仅 father 变量）。
2. son 销毁，Son 引用计数降至 1。
3. father 销毁，Father 引用计数降至 0，Father 对象析构。
4. Father 析构会清理其内部的 son_（shared_ptr），导致 Son 的引用计数随之归零，最终 Son 也被析构。

总结：如何选择智能指针？

在实际开发中，遵循以下原则进行选择：

• 首选 unique_ptr：除非明确需要共享所有权，否则一律使用 unique_ptr。它具有最小的运行时开销，且语义最清晰（谁持有，谁负责释放）。
• 使用 shared_ptr 的场景：当存在多个所有者时。例如：STL 容器中存储指针以便通用算法处理、多个父对象共用子对象等。
• 配合 weak_ptr 处理环状依赖：在树形结构、观察者模式或多层嵌套关系中，务必将“反向引用”声明为 weak_ptr 以打破循环。

以上就是 C++ 智能指针的详细解析，更多关于 C++ 高级特性的资料请关注本站其它相关文章！