RAII 与智能指针深度拆解

RAII 与智能指针深度拆解：unique_ptr / shared_ptr / weak_ptr 踩坑大全，杜绝内存泄漏

C++ 手动管理内存的三大致命伤------内存泄漏、野指针、重复释放------折磨了开发者数十年。C++11 用一套 RAII + 智能指针的组合拳，从语法层面彻底终结了这些顽疾。但这套武器用不好，反而会制造更隐蔽的坑。

本文从核心原理到工程避坑，一次性讲透。

---

一、RAII：一切智能指针的灵魂

RAII（Resource Acquisition Is Initialization，资源获取即初始化）的核心只有一句话：

资源在构造时获取，在析构时释放。对象活着，资源就在；对象死了，资源必清。

C++ 标准保证：任何情况下，已构造的对象最终会销毁，析构函数必然被调用。 无论正常 return、提前跳出、还是异常抛出，栈展开机制都会沿着作用域链逐一调用析构函数。

这意味着：你把资源塞进一个栈对象里，就再也不用操心释放的事了。

资源类型	STL 中的 RAII 实现	核心作用
动态内存	std::unique_ptr / std::shared_ptr	自动 delete，杜绝泄漏
文件句柄	std::fstream	构造时打开，析构时关闭
互斥锁	std::lock_guard / std::unique_lock	构造时加锁，析构时解锁
线程	自定义 thread_guard	析构时自动 join

RAII 是因，智能指针是果。 理解了 RAII，智能指针的一切行为都能推导出来。

---

二、三大智能指针：特性、对比、选择

C++11 标准化了三种智能指针，废弃了 C++98 的 auto_ptr（拷贝赋值会转移所有权，极易引发悬空指针，已彻底移除）。

2.1 unique_ptr ------ 独占所有权，性能之王

特性	说明
独占性	同一时刻只有一个 unique_ptr 指向堆对象
禁拷贝	拷贝构造/赋值被 =delete，杜绝资源复制冲突
支持移动	std::move 转移所有权，原指针自动置空
零开销	大小等同裸指针，无引用计数，无控制块

推荐创建方式：

cpp
// ✅ 推荐：make_unique，异常安全 + 一次分配
auto ptr = std::make_unique<int>(100);

// ⚠️ 不推荐：两次分配，异常不安全
std::unique_ptr<int> ptr(new int(100));

make_unique 把对象内存和管理数据合并分配，既高效又避免了"new 成功后、unique_ptr 绑定前抛异常导致泄漏"的边缘情况。

适用场景： 独占资源的默认首选------类成员指针、函数返回值、容器存储。

2.2 shared_ptr ------ 共享所有权，引用计数

特性	说明
共享性	多个 shared_ptr 可指向同一对象
引用计数	内部维护控制块（引用计数 + 弱计数 + 删除器）
拷贝/赋值	引用计数 +1；析构/重置
开销	双指针结构（数据指针 + 控制块指针），有内存和性能成本

推荐创建方式：

cpp
// ✅ 推荐：make_shared，一次分配，效率更高
auto sp = std::make_shared<int>(66);

// ⚠️ 不推荐：两次分配，且多个 shared_ptr 共用同一裸指针会崩溃
std::shared_ptr<int> p1(new int(1));
std::shared_ptr<int> p2(new int(1)); // 错误！两个独立控制块，重复释放

一个裸指针初始化多个 shared_ptr = 未定义行为。 下面这段代码会导致 double free：

cpp
int* raw = new int(42);
std::shared_ptr<int> p1(raw);
std::shared_ptr<int> p2(raw); // 💥 p1、p2 各有独立控制块，析构时各 delete 一次

2.3 weak_ptr ------ 弱引用，循环引用的唯一解药

特性	说明
不增加引用计数	仅观察，不拥有
不能直接访问	必须 lock() 转为 shared_ptr 才能用
检测存活	expired() / lock() 返回空判断

核心用途只有一个：打破 shared_ptr 的循环引用。

cpp
struct Node {
    std::shared_ptr<Node> next;   // 强引用
    std::weak_ptr<Node> prev;     // 弱引用，不增加计数
};

auto n1 = std::make_shared<Node>();
auto n2 = std::make_shared<Node>();
n1->next = n2;
n2->prev = n1; // ✅ 不增加 n1 的引用计数，析构时正常释放

如果 prev 也用 shared_ptr，n1 和 n2 相互持有，引用计数永远不归零，内存永久泄漏。

---

三、踩坑大全：90% 的人会犯的错误

坑 1：用同一个裸指针初始化多个 shared_ptr

cpp
int* p = new int(10);
std::shared_ptr<int> sp1(p);
std::shared_ptr<int> sp2(p); // 💥 double free

正确做法： 先创建一个 shared_ptr，再拷贝给其他的。

cpp
auto sp1 = std::make_shared<int>(10);
auto sp2 = sp1; // ✅ 共享同一个控制块

坑 2：在函数参数中创建 shared_ptr

cpp
// ⚠️ 危险：参数求值顺序不确定，g() 若抛异常，内存泄漏
function(std::shared_ptr<int>(new int), g());

// ✅ 正确：先创建，再传参
auto sp = std::make_shared<int>(10);
function(sp, g());

坑 3：shared_ptr 循环引用

cpp
struct A { std::shared_ptr<B> b; };
struct B { std::shared_ptr<A> a; };
// a 和 b 相互持有，引用计数永远 ≥ 1，永远不释放 💥

解法 ： 强弱搭配。通常父节点用 shared_ptr，子节点用 weak_ptr 指回父节点。

坑 4：weak_ptr 直接解引用

cpp
std::weak_ptr<int> wp = sp;
*wp; // 💥 编译错误，weak_ptr 不能解引用

正确做法：

cpp
if (auto locked = wp.lock()) {
    std::cout << *locked; // ✅ 安全访问
} else {
    std::cout << "已释放";
}

坑 5：get() 返回值保存为裸指针

cpp
auto sp = std::make_shared<int>(42);
int* raw = sp.get(); // ⚠️ 不要保存这个值
// sp 离开作用域后，raw 变成悬空指针

更不要手动 delete：

cpp
delete sp.get(); // 💥 shared_ptr 析构时会再 delete 一次，double free

坑 6：shared_ptr<T>(this) 返回自身

cpp
class Foo {
public:
    std::shared_ptr<Foo> get_self() {
        return std::shared_ptr<Foo>(this); // 💥 多个独立控制块，重复释放
    }
};

正确做法 ： 继承 std::enable_shared_from_this<T>，用 shared_from_this()。

cpp
class Foo : public std::enable_shared_from_this<Foo> {
public:
    std::shared_ptr<Foo> get_self() {
        return shared_from_this(); // ✅ 共用控制块
    }
};

坑 7：自定义删除器忘了写

管理非 new 资源时（FILE*、HANDLE、malloc 内存），必须指定删除器：

cpp
// ✅ 文件句柄
auto file = std::unique_ptr<FILE, decltype(&fclose)>(
    fopen("data.txt", "r"), &fclose
);

// ✅ malloc 内存
auto buf = std::unique_ptr<void, decltype(&free)>(
    malloc(1024), &free
);

// ✅ OpenGL 纹理
auto tex = std::unique_ptr<GLuint, decltype(&glDeleteTextures)>(
    new GLuint, [](GLuint* p) { glDeleteTextures(1, p); delete p; }
);

---

四、优先级与选择指南

场景	推荐	理由
独占所有权	unique_ptr	零开销，默认首选
共享所有权	shared_ptr	引用计数自动管理
打破循环引用	weak_ptr	不增加计数，仅观测
缓存/观察者	weak_ptr	避免缓存持有导致资源无法释放
数组	unique_ptr<T[]>	匹配 delete[] 释放规则
C 风格资源	unique_ptr + 自定义删除器	统一管理 FILE*、HANDLE 等

业务开发优先级：unique_ptr > shared_ptr > weak_ptr。 能用独占就不用共享，最小化资源耦合。

---

五、一句话总结

RAII 是 C++ 内存安全的基石，智能指针是 RAII 最锋利的工具。unique_ptr 守住独占的底线，shared_ptr 撑起共享的伞，weak_ptr 拆掉循环引用的炸弹。 记住三条铁律：不用裸指针初始化多个 shared_ptr、不用 shared_ptr 相互持有、weak_ptr 用前必 lock------内存泄漏这个词，就可以从你的字典里删掉了。