先看两个现场。第一个:一个读配置的函数,读到第三行发现格式不对,顺手 return false。文件句柄没关,日志停在半行;更麻烦的是它进函数时锁了一把互斥量,返回时忘了解,第二次运行直接卡在启动阶段。

第二个:一个管缓冲区的类,按值传给另一个函数处理。函数返回时局部对象析构一次,外面那个对象离开作用域时又析构一次,同一块内存被 delete[] 了两次。本机跑出来的退出码是 -1073740940(0xC0000374,堆损坏),连之前 printf 的内容都没刷出来。

两个 bug 的共同点是:资源的寿命和对象的寿命没绑在一起。前一个靠人记得在每条出口释放,后一个靠人记得写拷贝构造。C++ 的正解叫 RAII,把「获取资源」放进构造函数,把「释放资源」放进析构函数,剩下的交给作用域。这篇就拆这套机制:构造和析构到底按什么顺序跑,RAII 为什么连 return 和异常都能兜住,拷贝和移动分别意味着什么,以及虚析构、对象切片、析构抛异常这几个坑。

本文按 C++20 写。代码在本机 Windows + MinGW g++ 16.2.0 上以 -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、数据库连接、临时文件。判断标准只有一条:这个对象的析构能不能确定地、无异常地把资源还回去。

Linux 上编译带 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:容器和算法,看看标准库是怎么用这些语言机制,把内存管理和遍历逻辑收进几个通用组件的。