一、RAII到底解决什么问题
先看最普通的动态内存管理：
void func() { int *p = new int(10); std::cout << *p << std::endl; delete p; }正常情况下：
new ↓ 使用资源 ↓ delete没有问题。
但如果代码变成：
void func(bool flag) { int *p = new int(10); if (flag) return; delete p; }如果：
flag == true函数提前：
return;那么：
delete p;不会执行。
最终就可能产生：
内存泄漏异常同样存在这个问题：
void func() { int *p = new int(10); doSomething(); // 如果这里抛异常 delete p; }一旦：
doSomething();抛出异常，后面的：
delete p;同样可能无法执行。
所以直接手动管理资源存在一个核心问题：
获取资源容易 但是必须保证 所有退出路径 都能够正确释放资源如果函数比较复杂：
return 异常 多个if 多个资源就越来越容易遗漏。
RAII 的思路就是：
不要让程序员自己到处记住什么时候释放资源，而是让对象的析构函数负责。
RAII 全称：
Resource Acquisition Is Initialization通常翻译为：
资源获取即初始化它的基本思想：
对象构造 ↓ 获取资源 对象使用 ↓ 资源存在 对象离开作用域 ↓ 自动调用析构函数 ↓ 释放资源所以：
资源生命周期被绑定到了：
对象生命周期这就是 RAII 最核心的思想。
二、手写一个最简单的RAII对象
还是使用动态内存举例。
可以写一个简单的资源管理类：
class IntResource { private: int *ptr_; public: explicit IntResource(int value) { ptr_ = new int(value); } ~IntResource() { delete ptr_; } int &get() { return *ptr_; } };使用：
void func() { IntResource resource(10); std::cout << resource.get() << std::endl; }进入：
func()以后：
构造IntResource ↓ new int(10)函数结束：
resource离开作用域 ↓ 自动调用析构函数 ↓ delete ptr_此时不需要手动：
delete更重要的是，如果中间提前返回：
void func(bool flag) { IntResource resource(10); if (flag) return; std::cout << resource.get() << std::endl; }即使：
return;resource仍然需要正常离开作用域，因此它的析构函数会被调用。
流程：
创建resource ↓ 获取资源 ↓ 提前return ↓ resource生命周期结束 ↓ 调用析构函数 ↓ 自动释放资源如果发生异常，也是类似的思想。
例如：
void func() { IntResource resource(10); throw std::runtime_error("error"); }发生异常以后，在正常的栈展开过程中，已经构造完成的局部对象会被销毁。
所以：
~IntResource()仍然会执行。
这就是 RAII 一个非常重要的优点：
正常结束 提前return 异常退出都可以利用对象生命周期帮助管理资源。
因此 RAII 并不是一个特殊语法。
它其实是一种：
设计思想核心就是：
构造函数负责获取资源 析构函数负责释放资源三、智能指针为什么属于RAII
前面已经手写过：
unique_ptr shared_ptr weak_ptr其中：
unique_ptr shared_ptr就是 RAII 非常典型的应用。
例如：
std::unique_ptr<int> p(new int(10));实际上就是：
unique_ptr构造 ↓ 接管new出来的资源 ↓ 使用资源 ↓ unique_ptr析构 ↓ 自动delete所以原本：
int *p = new int(10); // 使用 delete p;变成：
auto p = std::make_unique<int>(10); // 使用不再需要手动：
delete对象离开作用域以后：
unique_ptr析构 ↓ 自动释放资源例如：
void func() { auto p = std::make_unique<int>(10); std::cout << *p << std::endl; }函数结束：
p离开作用域 ↓ ~unique_ptr() ↓ 释放int对象shared_ptr也是类似思想。
只不过：
unique_ptr通过：
独占所有权决定什么时候释放。
而：
shared_ptr通过：
引用计数决定什么时候释放。
所以：
RAII是更大的设计思想。
而：
智能指针是 RAII 在：
动态内存管理上的一种具体应用。
两者关系可以理解成：
RAII │ ┌────────┼────────┐ ↓ ↓ ↓ 智能指针 锁管理 文件管理因此如果面试问：
智能指针为什么能防止内存泄漏？
不能只回答：
因为它会自动delete更完整的回答是：
智能指针利用 RAII，把动态资源的生命周期和智能指针对象的生命周期绑定起来，当智能指针离开作用域时，析构函数自动释放资源，从而减少手动资源管理带来的泄漏风险。
四、RAII不只是管理内存
这是理解 RAII 时非常重要的一点。
很多人第一次接触 RAII 会认为：
RAII = 智能指针其实并不是。
RAII 管理的是：
资源而资源不仅仅包括内存。
例如：
动态内存 文件 互斥锁 Socket 数据库连接 文件描述符都可以使用 RAII 思想管理。
例如多线程中的：
std::mutex mutex;最直接的写法：
mutex.lock(); // 临界区代码 mutex.unlock();同样存在问题。
如果中间：
return;或者：
throw;可能导致：
mutex.unlock();没有执行。
锁就一直没有释放。
RAII 的方式：
std::lock_guard<std::mutex> lock(mutex);例如：
void func() { std::lock_guard<std::mutex> lock(mutex); // 临界区代码 }创建：
lock时：
构造lock_guard ↓ mutex.lock()离开作用域：
lock_guard析构 ↓ mutex.unlock()即使：
void func(bool flag) { std::lock_guard<std::mutex> lock(mutex); if (flag) return; }发生：
return;也会先析构局部对象。
所以：
lock_guard ↓ 自动unlock这就是 RAII 在互斥锁管理上的应用。
文件资源也是类似。
例如 C 风格：
FILE *fp = fopen("test.txt", "r"); if (!fp) return; // 使用文件 fclose(fp);必须自己记得：
fclose(fp);而 C++：
std::ifstream file("test.txt");文件流对象离开作用域以后，会自动关闭底层文件资源。
因此可以理解成：
内存 ↓ unique_ptr / shared_ptr mutex ↓ lock_guard / unique_lock 文件 ↓ fstream 其他资源 ↓ 自己设计RAII包装类甚至 Socket 也可以自己封装：
class Socket { private: int fd_; public: explicit Socket(int fd) : fd_(fd) {} ~Socket() { if (fd_ >= 0) close(fd_); } };于是：
Socket对象存在 ↓ fd有效 Socket对象销毁 ↓ 自动close(fd)所以 RAII 真正关注的是：
任何需要“获取以后必须释放”的资源，都可以考虑通过对象生命周期进行管理。
五、RAII面试中最容易追问什么
第一个很常见的问题：
RAII到底是什么意思？
可以直接回答：
RAII 是 Resource Acquisition Is Initialization，也就是资源获取即初始化。核心思想是把资源生命周期和对象生命周期绑定起来，在对象构造时获取资源，在析构时释放资源。这样对象离开作用域时会自动清理资源，可以减少内存泄漏、忘记解锁等问题，并提高异常安全性。
可以简单记成：
构造函数 ↓ 获取资源 析构函数 ↓ 释放资源第二个问题：
RAII和智能指针是什么关系？
可以回答：
RAII 是一种资源管理思想，而智能指针是 RAII 在动态内存管理中的具体应用。
unique_ptr和shared_ptr都通过析构函数自动释放所管理的资源。
也就是说：
RAII ↓ 思想 unique_ptr/shared_ptr ↓ 具体实现不要说：
RAII就是智能指针因为：
std::lock_guard同样属于 RAII。
第三个问题：
RAII为什么有利于异常安全？
因为如果：
new lock open以后手动：
delete unlock close一旦中间发生异常：
后面的清理代码 可能执行不到而 RAII：
资源交给局部对象 ↓ 发生异常 ↓ 栈展开 ↓ 局部对象析构 ↓ 释放资源所以资源释放不需要依赖正常走到函数末尾。
第四个问题：
析构函数为什么通常不应该抛异常？
RAII 的资源释放逻辑一般放在：
析构函数中。
如果程序本来就在：
异常栈展开过程中，而析构函数又抛出新的异常，可能最终触发：
std::terminate()所以资源管理类的析构函数通常应该：
尽量保证不抛异常例如：
~Resource() noexcept { release(); }这也是设计 RAII 类时比较重要的一点。
第五个问题：
自己写RAII类时还要考虑什么？
如果类内部拥有：
T *ptr_;这类独占资源，就不能只写：
构造函数 析构函数还需要考虑：
拷贝构造 拷贝赋值 移动构造 移动赋值否则默认浅拷贝可能导致：
两个对象 指向同一资源 ↓ 析构时重复释放这就会进一步涉及：
Rule of Three Rule of Five也就是前面移动语义和智能指针中已经遇到的内容。
所以几个知识点其实是连起来的：
RAII ↓ 对象负责资源生命周期 ↓ 对象可能发生拷贝 ↓ 需要处理资源所有权 ↓ 拷贝构造 / 拷贝赋值 ↓ 移动语义 ↓ Rule of Five最后把 RAII 整体流程整理一下：
程序需要资源 ↓ 创建RAII对象 ↓ 构造函数获取资源 ↓ 对象负责管理资源 ↓ 正常执行 / return / 异常 ↓ 对象离开作用域 ↓ 析构函数自动执行 ↓ 释放资源如果面试官问：
C++为什么特别强调RAII？
可以这样回答：
因为 C++ 中很多资源需要显式管理，例如动态内存、文件、锁和 Socket。RAII 利用 C++ 对象确定的析构机制，把资源释放封装进析构函数，使资源能够随着对象生命周期自动释放，从而降低资源泄漏风险，并且对提前返回和异常路径更加安全。
如果继续问：
举几个标准库中的RAII例子。
可以回答：
std::unique_ptr std::shared_ptr std::lock_guard std::unique_lock std::fstream它们虽然管理的资源不同，但共同思想都是：
资源交给对象管理 对象销毁 资源自动释放所以 RAII 真正重要的不是把：
Resource Acquisition Is Initialization这句话背下来。
而是理解：
不要让裸资源在代码中到处流动 ↓ 尽量交给一个对象管理 ↓ 让对象生命周期控制资源生命周期这也是现代 C++ 资源管理中非常重要的一条原则。
0voice · GitHub
