先看两个现场。第一个:一个读配置的函数,读到第三行发现格式不对,顺手 return false。文件句柄没关,日志停在半行;更麻烦的是它进函数时锁了一把互斥量,返回时忘了解,第二次运行直接卡在启动阶段。
第二个:一个管缓冲区的类,按值传给另一个函数处理。函数返回时局部对象析构一次,外面那个对象离开作用域时又析构一次,同一块内存被 delete[] 了两次。本机跑出来的退出码是 -1073740940(0xC0000374,堆损坏),连之前 printf 的内容都没刷出来。
两个 bug 的共同点是:资源的寿命和对象的寿命没绑在一起。前一个靠人记得在每条出口释放,后一个靠人记得写拷贝构造。C++ 的正解叫 RAII,把「获取资源」放进构造函数,把「释放资源」放进析构函数,剩下的交给作用域。这篇就拆这套机制:构造和析构到底按什么顺序跑,RAII 为什么连 return 和异常都能兜住,拷贝和移动分别意味着什么,以及虚析构、对象切片、析构抛异常这几个坑。
-std=c++20 -Wall -Wextra 编译运行,输出照抄。涉及 Linux 或本机缺少的工具会单独标注;没有实测的结论会写明。构造与析构的真实顺序
很多人以为初始化列表里先写的成员就先构造。编译器不这么干。成员的构造顺序只由声明顺序决定,初始化列表只是提供初值,不改变构造次序。析构则严格反过来:先执行析构函数体,再按声明逆序销毁成员,最后销毁基类。
写个能直接看出顺序的小程序,故意把初始化列表写反:
#include <iostream>
#include <string>
struct Trace {
std::string name;
explicit Trace(std::string n) : name(std::move(n)) {
std::cout << " + " << name << "\n";
}
~Trace() { std::cout << " - " << name << "\n"; }
};
class Session {
public:
Session() : log_("log"), conn_("conn") { // 故意写反
std::cout << " Session body\n";
}
~Session() { std::cout << " ~Session\n"; }
private:
Trace conn_;
Trace log_;
};
int main() {
Session s;
return 0;
}
编译命令:
g++ -std=c++20 -Wall -Wextra session_demo.cpp -o app.exe
.\app.exe
本机输出:
+ conn
+ log
Session body
~Session
- log
- conn
初始化列表写的是 log_ 在前,实际构造顺序是 conn_ 先,因为声明里 conn_ 写在 log_ 前面。析构完全对称:后构造的 log_ 先销毁。编译器其实早就看出不对劲,-Wall -Wextra 下给了这条警告:
warning: 'Session::log_' will be initialized after [-Wreorder]
warning: 'Trace Session::conn_' [-Wreorder]
warning: when initialized here [-Wreorder]
这条警告值得当成错误对待。假设 log_ 的构造要用 conn_ 的成员,而 conn_ 声明在后面,那它读到的是一个还没构造的对象,表现为随机值、空字符串、甚至崩溃,而且换个编译器可能又「好了」。
为什么语言要规定死顺序?因为初始化列表可以只写一部分成员、可以写表达式,但对象的内存布局和构造点是固定的。只有按声明顺序走,编译器和读代码的人才能用同一套规则推断行为。析构逆序则保证依赖关系不会倒挂:后构造的成员可能依赖先构造的,先销毁它才安全。
RAII 到底靠什么生效
RAII 的全称是 Resource Acquisition Is Initialization,直译很别扭。它的实际意思只有一句:把资源的获取放进构造函数,把释放放进析构函数,让资源的寿命跟着对象的作用域走。
它之所以有效,不是因为什么运行时代理,而是因为语言保证了三件事:正常离开作用域会调用析构;return 离开作用域会调用析构;抛出异常做栈展开时,也会调用已经构造完成的对象的析构。也就是说,只要资源被一个局部对象持有,你就不用再关心函数有几个出口、中间会不会抛。
拿互斥量做个对照实验。左边是手工 lock/unlock,右边是 std::lock_guard,两条路都在中途提前返回:
#include <cstdio>
#include <mutex>
#include <thread>
std::mutex mtx;
void bad_path() {
mtx.lock();
if (true) {
return; // 锁没解
}
mtx.unlock();
}
void good_path() {
std::lock_guard<std::mutex> guard(mtx);
if (true) {
return; // guard 析构时自动解锁
}
}
void probe(const char* tag) {
std::thread t([tag] {
if (mtx.try_lock()) {
std::printf("%s: acquired\n", tag);
mtx.unlock();
} else {
std::printf("%s: still locked\n", tag);
}
});
t.join();
}
int main() {
bad_path();
probe("after bad_path");
mtx.unlock();
good_path();
probe("after good_path");
return 0;
}
这里用另一个线程去 try_lock,是为了避免同一线程对已持有的非递归锁再次加锁(那属于未定义行为)。编译运行:
g++ -std=c++20 -Wall -Wextra mutex_demo.cpp -o app.exe
.\app.exe
本机输出:
after bad_path: still locked
after good_path: acquired
结果很清楚:手工路径提前返回后锁还在,探针线程拿不到;guard 路径同样提前返回,但离开作用域时 lock_guard 的析构函数调用了 unlock,锁已经放开。所谓「智能」,全部写在这个析构函数里,没有任何魔法。
同一套机制撑起了标准库一大批类型:std::unique_ptr 在析构里 delete,std::fstream 在析构里关文件,std::jthread 在析构里请求停止并 join,std::lock_guard、std::unique_lock 在析构里解锁。你写业务代码时也可以照这个模式封自己的资源:句柄、socket、数据库连接、临时文件。判断标准只有一条:这个对象的析构能不能确定地、无异常地把资源还回去。
std::thread 的程序通常要加 -pthread;本机 MinGW 不加也能过,这一点没有在 Linux 上实测。完整走查:一个不会漏关文件的读取器
把第一个现场补成能跑的版本。目标是读一个四行的文本文件,逐行检查是否完整,中途任何异常路径都不能漏关文件。做法是给 std::FILE* 配一个自定义删除器,交给 std::unique_ptr 持有:
// file_raii.cpp
#include <cstdio>
#include <fstream>
#include <memory>
#include <string>
struct FileCloser {
void operator()(std::FILE* f) const noexcept {
if (f) {
std::fclose(f);
std::printf(" file closed\n");
}
}
};
using FilePtr = std::unique_ptr<std::FILE, FileCloser>;
static FilePtr open_read(const char* path) {
return FilePtr(std::fopen(path, "rb"));
}
int main() {
{
std::ofstream out("data.txt");
out << "alpha\nbeta\ngamma\ndelta\n";
}
FilePtr f = open_read("data.txt");
if (!f) {
std::printf("open failed\n");
return 1;
}
std::printf("file opened\n");
char line[64];
int count = 0;
int bad = 0;
while (std::fgets(line, sizeof(line), f.get())) {
std::string s(line);
if (s.find('\n') == std::string::npos) {
std::printf("truncated line, stop\n");
++bad;
break;
}
++count;
}
std::printf("lines=%d bad=%d\n", count, bad);
if (count == 4) {
std::printf("early return path\n");
return 0; // 这里直接返回,f 仍会被析构
}
std::printf("normal end\n");
return 0;
}
编译和运行:
g++ -std=c++20 -Wall -Wextra file_raii.cpp -o app.exe
.\app.exe
本机输出:
file opened
lines=4 bad=0
early return path
file closed
注意最后一行:early return path 之后程序直接 return 0,没有走到函数末尾,但 file closed 仍然打出来了。f 是 main 的局部对象,return 触发它的析构,FileCloser 里的 fclose 被执行。如果这里写的是裸 FILE* f = std::fopen(...),这条提前返回就是一次泄漏——文件描述符要等到进程结束才回收,Windows 上还可能因为文件被占用导致别的模块打不开。
两个细节:f.get() 只是把裸指针借给 fgets,所有权仍在 f 身上;if (!f) 能用,是因为 unique_ptr 定义了到 bool 的转换,空指针时为 false。删除器写成 noexcept,因为析构函数默认就是 noexcept,这条下一节还会讲。
拷贝、移动,与 rule of zero / three / five
编译器会为类自动生成拷贝构造、拷贝赋值、移动构造、移动赋值和析构——前提是你没自己写。这些默认版本做的是逐成员拷贝:每个成员各自拷贝一次。成员是 std::string、std::vector,它们自己的拷贝构造会深拷贝;成员是裸指针,那就只拷地址。
于是就有了第二个现场。下面这个类没有写拷贝构造,按值传递时会得到两个对象,各自持着同一个指针:
#include <cstdio>
struct Buf {
int* p;
explicit Buf(int n) : p(new int[n]) { std::printf("alloc %p\n", (void*)p); }
~Buf() { std::printf("free %p\n", (void*)p); delete[] p; }
};
int main() {
Buf a(4);
{
Buf b = a; // 默认拷贝:b.p 和 a.p 指向同一块
std::printf("b copied, b.p=%p\n", (void*)b.p);
}
std::printf("after inner scope\n");
return 0;
}
本机运行结果:进程在离开内层作用域时直接终止,退出码 -1073740940(0xC0000374),之前的所有 printf 一条都没输出(stdout 缓冲区还没来得及刷新)。第一次 delete[] 已经把内存还回去,第二次再删就是堆损坏。
这件事的教训不是「记得写拷贝构造」,而是「别让类自己管裸资源」。于是有了三条实践规则:
rule of zero
类里只放 std::string、std::vector、std::unique_ptr 这类已经管好资源的成员,自己不写析构、拷贝、移动。编译器生成的版本逐成员处理,全部正确。绝大多数业务类应该停在这一档。
rule of three / five
确实要自己持有裸资源时,写了析构就得写拷贝构造和拷贝赋值(三);C++11 起再加移动构造和移动赋值(五)。漏一个,编译器就会悄悄生成默认版本,把资源管成两份。
自己实现移动时,核心动作是把资源从源对象「偷」过来,并把源对象置成可安全析构的状态。看这个正确的版本:
#include <algorithm>
#include <iostream>
#include <utility>
class Owner {
public:
explicit Owner(int n) : p_(new int[n]), n_(n) {
std::cout << "Owner alloc " << n_ << "\n";
}
Owner(const Owner& other) : p_(new int[other.n_]), n_(other.n_) {
std::copy(other.p_, other.p_ + n_, p_);
std::cout << "Owner copy\n";
}
Owner(Owner&& other) noexcept : p_(other.p_), n_(other.n_) {
other.p_ = nullptr;
other.n_ = 0;
std::cout << "Owner move\n";
}
Owner& operator=(const Owner&) = delete;
~Owner() { delete[] p_; std::cout << "Owner free " << n_ << "\n"; }
private:
int* p_;
int n_;
};
int main() {
Owner a(3);
Owner b(std::move(a));
return 0;
}
本机输出:
Owner alloc 3
Owner move
Owner free 3
Owner free 0
被移动的 a 仍然会析构,这没法避免;但它的 p_ 被置成 nullptr、n_ 归零,所以 delete[] nullptr 什么也不做,打印出来是 Owner free 0。移动构造标了 noexcept,这一点很重要:容器在扩容搬家时会优先用 noexcept 的移动构造,否则为了异常安全可能退回拷贝。
std::move 本身不搬任何东西,它只是把左值转成右值引用,真正干活的是移动构造或移动赋值。移动之后的对象处于「有效但未指定」的状态,能析构、能重新赋值,但不要读它的内容——标准不保证里面还剩什么。
如果类根本不该被拷贝(比如持有锁、线程、文件写入权),最省事的是把拷贝构造和拷贝赋值标成 = delete,让编译器在调用点直接报错,而不是等到运行时双析构。
虚析构与对象切片
多态基类有一个硬性要求:析构函数必须是虚的。否则通过基类指针 delete 派生对象时,只调用基类析构,派生类里申请的资源不会被释放。这不是理论问题,本机就能复现:
#include <cstdio>
struct Base {
virtual void hello() const { std::printf("Base::hello\n"); }
~Base() { std::printf("~Base\n"); }
};
struct Derived : Base {
explicit Derived() : buf(new int[8]) { std::printf("Derived ctor\n"); }
void hello() const override { std::printf("Derived::hello\n"); }
~Derived() { delete[] buf; std::printf("~Derived\n"); }
int* buf;
};
int main() {
Base* p = new Derived();
p->hello();
delete p; // 基类析构不是 virtual
std::printf("after delete\n");
return 0;
}
本机输出:
Derived ctor
Derived::hello
~Base
after delete
~Derived 一次都没出现,buf 泄漏了。编译器其实提醒过:
warning: 'struct Base' has virtual functions and accessible non-virtual destructor [-Wnon-virtual-dtor]
warning: deleting object of polymorphic class type 'Base' which has non-virtual destructor
might cause undefined behavior [-Wdelete-non-virtual-dtor]
修法很简单:virtual ~Base() = default;。只要类有虚函数、并且可能被别人通过指针删除,析构就得是虚的。成本是每个对象多一个虚表指针,以及析构要走一次间接调用;在多态基类上这笔钱必须花。
另一个相关的问题是对象切片(object slicing):把派生对象按值塞进基类类型的容器或参数,派生部分被切掉,只剩基类子对象。虚函数也救不了,因为容器里存的就是一个 Base 对象,虚表指针指向 Base 的虚表。
#include <cstdio>
#include <vector>
struct Base {
virtual void hello() const { std::printf("Base::hello\n"); }
virtual ~Base() { std::printf("~Base\n"); }
};
struct Derived : Base {
void hello() const override { std::printf("Derived::hello\n"); }
~Derived() override { std::printf("~Derived\n"); }
};
int main() {
std::vector<Base> v;
v.push_back(Derived{}); // 只拷贝 Base 子对象
v[0].hello(); // 调用的是 Base::hello
return 0;
}
本机输出:
~Derived
~Base
Base::hello
~Base
前两行是 push_back 结束后临时对象被销毁(先 ~Derived 再 ~Base);中间一行说明进入容器的副本已经只剩基类,虚函数调用走了 Base::hello;最后一行是容器里的副本在 main 结束时析构。派生部分从头到尾没有进入容器。
析构函数里不要抛异常
C++11 起,析构函数默认是 noexcept 的。也就是说,异常一旦从析构里逃出来,程序直接 std::terminate,不会给任何人 catch 的机会。原因很实际:栈展开过程中本来就在处理一个异常,如果析构再抛一个,两个异常同时存在,语言没法决定该传播哪个,只能终止。
把析构显式标成 noexcept(false) 可以让异常被 catch 住。本机试过:
#include <cstdio>
struct F {
~F() noexcept(false) { throw 1; }
};
int main() {
try {
F f;
} catch (...) {
std::printf("caught in main\n");
}
std::printf("end of main\n");
return 0;
}
输出是 caught in main 和 end of main,确实能接住。但这不是推荐写法:调用方不可能为「对象离开作用域」准备一个 catch,而且这个析构如果发生在另一个异常展开的过程中,照样会 terminate。用默认 noexcept 的版本跑一次,进程直接以非 0 状态结束(本机拿到退出码 3),一条输出都没有。
正确姿势是让析构「不失败」:可能失败的清理动作在析构里用 try/catch 包住,记录日志或设置错误标志,绝不向外抛。如果调用方必须知道关闭是否成功,就额外提供一个显式的 close() 返回错误码,析构只做兜底。标准的文件流、数据库连接封装基本都是这个结构。
现象、原因、先查什么
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
函数提前 return,文件句柄或锁没释放 | 资源是手工获取的,没有绑定到对象作用域 | 列出函数所有出口;把资源换成 lock_guard、unique_ptr 或自定义 RAII 包装 |
| 对象拷贝后析构两次,退出码 0xC0000374 | 默认拷贝是浅拷贝,两个对象拥有同一份资源 | 查是否自己持有裸指针且没写拷贝构造;改成 rule of zero 或 = delete |
| 成员构造顺序和初始化列表不一致 | 成员按声明顺序构造,列表只提供初值 | 看 -Wreorder 警告;把依赖关系按声明顺序理顺 |
基类指针 delete 派生对象,派生析构没执行 | 基类析构不是虚函数,只销毁了基类子对象 | 给多态基类加 virtual ~Base() = default; |
| 容器里存派生对象,虚函数却走基类版本 | 对象切片,按值存只保留了基类部分 | 改存 unique_ptr<Base> 或传引用;检查按值传参的接口 |
| 析构里一抛异常,进程直接没了 | 析构默认 noexcept,抛出即 std::terminate | 把析构里的清理包进 try/catch;需要报错就用显式 close() |
有引用成员或 const 成员的类,赋值编译失败 | 引用和 const 成员不可赋值,默认赋值运算符被删除 | 改用指针/值成员,或自己实现赋值并处理自赋值 |
| 移动之后源对象内容不对 | 移动构造没把源指针置空,两个对象都持有资源 | 检查移动实现是否 nullptr 了源成员,是否标了 noexcept |
表里第二条和第四条最值得背下来。前者是「自己管资源却没管拷贝」,后者是「多态基类没写虚析构」,两个都是编译器能提醒、但很多人把警告关掉就看不见的问题。
边界与代价:RAII 管不到的地方
RAII 很好用,但它有明确的适用边界,越界使用会出别的问题:
- 只能管作用域内的资源。连接池、全局缓存、需要跨请求复用的对象,寿命本来就比函数长,硬塞进局部对象只会让所有权变乱。这类资源需要专门的所有权类型或显式的生命周期管理,不能指望析构解决。
- 析构顺序本身是一种耦合。成员按声明逆序销毁,如果
b的析构要用a,就必须让a声明在b前面(后销毁)。这个依赖不会写在代码注释里,只能靠约定和评审发现。 - 全局和静态对象的析构顺序不可控。跨编译单元的顺序标准没有规定,本机也没有实测跨文件的情况。结论是:别在全局对象析构里依赖另一个全局对象,日志、配置这类东西尤其危险。
- 构造失败时,析构不会执行。构造函数抛异常,只有已经构造完成的成员会被销毁,构造函数体里手工获取的资源不会自动回滚。所以构造过程中每一步获取都要立刻交给 RAII 成员,而不是先拿裸句柄再慢慢包装。
- 析构不能报错。这是 RAII 的硬限制:文件关闭失败、
fflush失败,都只能吞掉或另行上报。需要精确错误处理的地方,必须提供显式的close()。 - rule of five 容易写错。自赋值、异常安全、移动后源状态,每一项都能写出 bug。能手写的地方尽量用 copy-and-swap,能不用手写就退回 rule of zero。
- 虚析构和切片是两笔账。虚析构让每个对象多一个虚表指针、析构多一次间接调用;按值传递又可能切掉派生部分。多态类最好只通过指针或引用传递,容器里存智能指针。
- 没装工具时,问题更难看见。本机没有 ASan 和 valgrind,double free 这类问题只能靠退出码和复现实验确认;有条件的环境应该在 CI 里开 ASan,代价是运行变慢、内存变大。
这些限制不是否定 RAII,而是提醒:它是一套「用作用域换确定性」的交易。作用域能覆盖的场景,它几乎是无脑正确;作用域覆盖不到的,必须换一种所有权模型,而不是给局部对象加个 release() 自欺欺人。
当天能验证的练习
- 把
Session那个例子抄下来,故意把初始化列表写反,确认-Wreorder警告和实际构造顺序;再调整声明顺序,让警告消失、输出顺序符合预期。 - 写一个函数,中途
return三次不同的分支,分别用裸std::fopen和unique_ptr加删除器实现,观察fclose是否被调用(可以打印一句话确认)。 - 把
Buf的拷贝构造删掉跑一次,记录退出码;再给它加= delete,确认编译器在拷贝点直接报错。 - 给
Base加上virtual ~Base() = default;,重跑虚析构那个例子,确认~Derived出现、buf被释放。 - 写一个带
std::mutex成员的类,把拷贝赋值标成= delete,然后尝试拷贝它,抄下编译错误,理解「不可拷贝」是怎么在编译期表达的。
小结
三句话:成员按声明顺序构造、按逆序析构,初始化列表不改变顺序;RAII 的全部力量来自「作用域结束时一定调析构」,所以资源要放进对象里,而不是散在函数的每条出口上;自己管资源就要面对拷贝和移动的语义,能交给 unique_ptr、string、vector 管就别手写析构。
对象怎么建、怎么销毁、怎么复制,讲完这一层,就可以把注意力放到「一堆对象怎么组织」上了。下一篇讲 STL:容器和算法,看看标准库是怎么用这些语言机制,把内存管理和遍历逻辑收进几个通用组件的。