先看现场。一个后台任务跑到某条记录时崩了,终端输出是空的,日志停在「开始处理第 138 条」。运维只拿到一个退出码。在 Linux 上,这类崩溃通常会留下一行:
terminate called after throwing an instance of 'std::invalid_argument'
what(): b must not be zero
这行信息看起来很具体:抛出的是 std::invalid_argument,原因是参数为零。但它没有告诉你是谁抛的、哪一层没接住、当时的输入是什么。一个进程里可能有几十处参数校验,光凭这一句话定位,等于大海捞针。更糟的是连这行都没有:本机 Windows 上实测,未捕获异常的程序异常退出,stdout 和 stderr 重定向到文件后都是 0 字节,只有退出码 541541187。终端里什么都没有。
这篇要解决的就是这个问题:弄清异常从抛出到终止之间到底发生了什么,怎么在每一层留下能用的上下文,以及什么时候根本不该用异常。读完之后,你应该能判断一个退出码异常的进程是「没接住异常」「违反了 noexcept」还是「踩了内存」,并且知道在本机哪些工具能用、哪些只是传说。
std::expected 在 C++23 下可用而在 C++20 下不可用、MinGW 缺少 ASan 运行库、本机没有 gdb,都是实跑结果。Linux 上 libstdc++ 的 terminate 输出格式、gdb 和 valgrind 的具体操作属于常规流程描述,未在本机实测,文中会单独标注。异常没人接住,到底发生了什么
C++ 的异常模型是「沿着调用栈往上找处理器」。函数里 throw 之后,编译器生成的运行时代码开始栈展开:一层层退出当前函数,退出时把该层已经构造完成的局部对象按逆序销毁,继续往上找 catch。如果一直找到 main 外面都没有匹配的处理器,就轮到 std::terminate。
std::terminate 的默认行为是调用 abort()。abort 不会执行栈展开,不会 flush 缓冲区,不保证写日志,也不给程序任何收尾机会。这解释了两件事:为什么未捕获异常时连 std::cout 里已经执行过的内容都可能看不到,为什么退出码不是普通的 1,而是平台相关的异常码。
本机那个 541541187(十六进制 0x20474343)是进程非正常终止留下的退出码,既不是业务错误码,也不是 HTTP 状态码。在 Linux 上,未捕获异常通常还会在 stderr 打印上面那种 terminate 提示;这一条是本机无法验证的,未在本机实测。两个平台表现不同,排查思路要分开:Windows 先看退出码和事件日志,Linux 先看 stderr 和 core dump。
顺带说清一个常见误解:catch 能接住的,只有「用 throw 抛出来的异常」。空指针解引用、数组越界、除零(整数)这些是未定义行为或信号,不会变成 C++ 异常。try/catch 包住代码也防不住段错误,两类问题的排查方法完全不同。
错误码还是异常:先划边界
这不是信仰问题,是成本问题。两种机制各有明确的适用区间,混着用才会出乱子。
错误码
适合「失败是常态」的场景:文件不存在、网络超时、用户输入非法、解析格式错误。调用方必须处理,编译器不会强制,但可以把错误当成普通数据传递。缺点是每层都要判断,容易漏查,构造函数里没法返回。
异常
适合「失败罕见且无法就地处理」的场景:资源分配失败、依赖库抛错、对象构造失败。它自动跳过中间层,不用每层写 if。代价是异常路径不直观,抛得太随意会让调用方猜不到要接什么。
工程上的划分通常是这样:
- 可预期的失败用错误码或返回类型。解析一行配置、打开一个用户指定的文件,这些失败太正常了,用异常会让正常路径和异常路径混在一起。
- 构造函数失败只能用异常。构造函数没有返回值,也没法让对象「半存在」。要么抛,要么用两段式初始化加一个
init()返回错误码,而后者的问题是:对象已经存在但不可用,析构函数要对半成品负责。 - 同一条调用链只选一种。底层返回错误码,中间层转成异常,上层再转回错误码,这种三层翻译最消耗人。要么在边界处翻译一次,要么全程统一。
C++17 给了 std::optional,用来表达「可能没有值」,但不带错误原因;C++23 的 std::expected 更进一步,值或错误二选一,还能携带错误类型。本机实测:GCC 16.2.0 用 -std=c++23 可以编译并运行 std::expected,输出正常;同一份代码用 -std=c++20 编译,报 'expected' in namespace 'std' does not name a template type。
#include <expected>
#include <iostream>
#include <string>
std::expected<int, std::string> parse_port(const std::string& s) {
if (s.empty()) {
return std::unexpected("empty");
}
try {
int v = std::stoi(s);
if (v < 0 || v > 65535) {
return std::unexpected("out of range");
}
return v;
} catch (...) {
return std::unexpected("not a number");
}
}
int main() {
for (const std::string s : {"8080", "70000", "abc"}) {
auto r = parse_port(s);
if (r) {
std::cout << s << " -> " << *r << "\n";
} else {
std::cout << s << " -> error: " << r.error() << "\n";
}
}
return 0;
}
运行输出(本机实测):
8080 -> 8080
70000 -> error: out of range
abc -> error: not a number
如果你的项目锁在 C++20,std::expected 就用不了,这一点已经实测确认。是否可以升到 C++23,要看编译器、标准库版本和团队约定,属于待确认项,不要因为一个返回类型就贸然改标准。C++20 里可行的替代是 optional 加一个额外的错误枚举,或者直接返回错误码。
完整走查:从捕获到没人接
下面是一个最小可复现的例子。函数在除数为零时抛出 std::invalid_argument,主函数里用 try/catch 接住。
#include <iostream>
#include <stdexcept>
int divide(int a, int b) {
if (b == 0) {
throw std::invalid_argument("b must not be zero");
}
return a / b;
}
int main() {
try {
std::cout << "10 / 2 = " << divide(10, 2) << "\n";
std::cout << "10 / 0 = " << divide(10, 0) << "\n";
} catch (const std::invalid_argument& e) {
std::cout << "caught: " << e.what() << "\n";
}
std::cout << "still running\n";
return 0;
}
编译运行(本机实测):
g++ -std=c++20 -Wall -Wextra -O0 exdemo.cpp -o exdemo.exe
.\exdemo.exe
10 / 2 = 5
10 / 0 = caught: b must not be zero
still running
退出码 0。注意第二行是拼接出来的:10 / 0 = 已经先写进了流,随后 divide(10, 0) 抛异常,表达式被中断,跳到 catch 里继续打印 caught: ...,两段接在了同一行。C++17 起 << 的求值顺序是从左到右,所以这里能看到前缀;更早的标准里顺序未指定,别依赖异常发生时输出究竟走到了哪一步。
把 try/catch 删掉,其余不变,就得到最开头那个场景。本机实测的结果是:没有任何输出(stdout 和 stderr 都是 0 字节),退出码 541541187。连 std::cout << "start\n" 都没留下,因为 abort 跳过了缓冲刷新。这点值得记住:未捕获异常时,你平时用来定位的那句日志,很可能根本没落盘。
栈展开在这个过程中做了什么?假设 divide 里有一个局部 std::string 或者 std::ofstream,抛异常时它们会被正常析构:内存释放、文件关闭。这是 RAII 在异常路径上的价值。反过来说,析构函数自己再抛异常,栈展开期间同时出现两个异常,运行时会直接调用 std::terminate。
main 外面设 std::set_terminate 注册处理器,在里面写日志然后退出,让「什么都没有」变成「至少知道抛了什么类型」。处理器里能用 std::current_exception() 取出正在传播的异常,但参数和调用栈仍要靠平台相关的栈回溯。真正有用的还是在抛出处把上下文带进异常对象。noexcept 不是装饰,是承诺
noexcept 的语义很硬:函数承诺不抛异常。一旦真的抛了,语言不给你捕获的机会,直接 std::terminate。所以它不是「优化提示」,而是接口契约。
什么时候该写:移动构造函数、移动赋值、swap、析构函数。这几个位置写 noexcept 会直接影响标准库的行为——std::vector 扩容时,只有在元素的移动构造是 noexcept 的前提下才会搬移,否则退回复制,保证强异常安全。析构函数在 C++11 之后默认就是 noexcept(true),显式改成可能抛一般意味着设计有问题。
什么时候不该写:函数内部会分配内存、会调用可能抛异常的库、会做字符串解析。noexcept 加在这些地方,等于把「可恢复的错误」升级成「直接终止进程」。判断方法很朴素:函数体里找不到可能抛的调用才考虑加;只要有一条路径可能抛,就别加。
还有一个容易忽略的点:noexcept 是函数类型的一部分。函数指针、std::function、回调注册时的签名都要一致。把带 noexcept 的函数塞进声明为可能抛的接口里通常没问题;反过来把可能抛的函数塞进 noexcept 接口,编译器可能直接拒绝。
异常安全的三档保证
异常安全不是「不出异常」,而是「出了异常之后,对象还处在什么状态」。通常分三档。
实现强保证的常用手法是 copy-and-swap:先在一份临时对象上完成修改,全部成功后再和 this 交换。交换本身通常不抛,于是旧状态要么完整保留,要么被完整替换。代价是每次修改都要复制一份,内存和拷贝开销翻倍,所以只对关键数据结构用。
析构函数绝对不能向外抛异常。它会在栈展开期间被调用,一旦抛出就是双异常,直接 terminate;即使不在展开期间,容器销毁元素时抛出也会让清理过程中断。清理失败(比如关闭文件失败)该记日志,不该 throw。
构造函数失败用异常最干净:异常一抛,对象不算构造成功,已构造完成的成员按逆序析构,不留半成品。两段式 init() 则必须接受「对象存在但不可用」,所有成员函数都得检查状态,更容易出错。
捕获的顺序与姿势
catch 的匹配规则是按书写顺序自上而下,第一个类型匹配的处理器生效,不做「最精确匹配」的挑选。所以派生类必须写在基类前面,否则基类的处理器会把派生类的异常也吃掉。
try {
risky();
} catch (const std::filesystem::filesystem_error& e) {
// 先接具体的
} catch (const std::exception& e) {
// 再接所有标准异常的基类
}
按 const& 捕获可避免拷贝异常对象,也避免对象切片——按值捕获基类会切掉派生类的额外信息,日志里只剩基类的 what()。用 catch (...) 只在两种场景合理:最外层兜底,记录「未知异常」后重新抛出;以及清理 C 风格资源后再抛出。空实现的 catch (...) 是危险写法,它把问题吞掉,程序带着错误状态继续跑,后面的异常现象离根因已经很远。
what() 通常只有一句话,信息量远不够。真正有用的是在抛出点携带上下文:哪个文件、哪一行输入、哪个请求 id、哪个用户。可以自定义异常类型把字段存进去,也可以在抛出前先写一条结构化日志。两者可以并用,最外层再记录一次。
throw 跳出循环、用异常表示「没找到」、在正常路径上频繁抛接,都会让代码难读、性能变差。这类情况用返回值、optional、状态枚举更合适。调试工具:能用与不能用的边界
工具解决的是「异常信息不够」的问题。先确认本机到底有什么,再谈流程。
- gdb:本机没有安装,执行
gdb --version报命令不存在。常规流程是:用-g -O0编译,gdb ./app.exe启动,break设断点,catch throw让程序在抛出点停下,bt看调用栈,info locals看局部变量。这条流程未在本机实测。 - ASan:本机 MinGW 的 g++ 不支持,实测编译通过、链接阶段报
cannot find -lasan,整体构建失败。要验证越界和悬垂访问,得换 Linux 上的 GCC/Clang,或用 MSVC 的 ASan 支持。使用方式是在编译和链接时都加-fsanitize=address -fno-omit-frame-pointer -g,运行时它会打印访问地址、分配位置和调用栈。未在本机实测,不编造输出。 - valgrind:Windows 上没有,本机也没有。它是 Linux 上的动态分析工具,
valgrind --leak-check=full ./app用来查泄漏和非法访问。速度会慢一个量级,适合排查而不是日常运行。未在本机实测。
三个工具的分工可以这样记:异常语义问题(谁抛的、谁没接)看栈,用 gdb;内存错误(越界、释放后使用、泄漏)用 ASan 或 valgrind;逻辑错误只能靠日志和复现。别拿 ASan 查「异常没接住」,它不负责那件事,而且本机链接不过。
在没有这些工具的环境里,最低成本的定位手段是三层日志:抛出点记录上下文,中间层记录「请求失败,准备上抛」,最外层记录类型和退出原因。这三条日志拼起来,比一行 terminate 提示有用得多。
排错表:现象、真实原因、先查什么
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
进程退出码 541541187,终端无输出(本机实测) | 异常一路没人接住,terminate 调用 abort,缓冲区未刷新 | 搜 throw 的抛出点与所有 catch;在 main 加顶层 try/catch 复现 |
stderr 只有 terminate called after throwing ...(Linux) | 同上,libstdc++ 在终止前打印了类型和 what() | 用 gdb 的 catch throw 定位抛出点;检查是否漏了某层捕获 |
函数一调用就崩,报 noexcept 相关终止 | 函数声明了 noexcept,内部却有路径抛异常 | 查该函数及它调用的所有函数是否可能抛;移动构造和 swap 最容易误标 |
异常信息只有空的 what() | 抛出时没给上下文,或自定义异常的 what() 返回了空串 | 改抛出点,携带文件、行号、参数、请求 id;不要只改 catch 里的日志 |
| catch 到了基类,派生类的信息丢了 | 捕获顺序错误,或按值捕获导致对象切片 | 把派生类处理器写在基类前面;确认参数是 const& 引用 |
| 出错后数据库连接、临时文件没释放 | 资源不是 RAII 管理,异常跳过了手写的释放代码 | 把裸资源换成对象封装;检查析构函数是否真的会执行 |
| 想用 ASan,链接失败 | MinGW 没有 libasan(本机实测 cannot find -lasan) | 换 Linux 工具链或 MSVC 的 ASan;别在 MinGW 上硬找 |
这张表里,退出码那一行最值得先做:拿到退出码,就能把「业务返回的错误码」和「进程异常终止」分开。前者通常是小数字,且程序会有正常输出;后者是平台异常码,且往往伴随输出缺失。
边界与代价
- 异常不是零成本的。主流实现采用「零成本异常」:不抛时几乎没有开销,代价是二进制体积变大、异常表占空间,抛出时的栈展开较慢;在每秒几万次的路径上抛异常,性能会明显下降。
- 可以关闭异常。
-fno-exceptions会禁用异常,标准库的部分功能也随之受限,适合嵌入式或对体积极端敏感的场景。团队一旦选了这条路,就不能边用try/catch边期望它工作。 - 异常不能跨语言边界随便传。C 接口、C 库回调、部分系统 API 都不认识 C++ 异常,让异常穿过
extern "C"边界属于未定义行为。边界处必须catch (...)后转成错误码。 - 错误码也有代价。每个调用点都要判断,漏一个就静默带错;构造函数用不了;深层调用链要一层层手工传递,代码里会多出大量样板。
- 调试工具依赖环境。本机没有 gdb 和 ASan 运行库,很多教程里的操作在这里跑不起来。先搞清楚手上有什么,比背命令更重要。
当天能验证的练习
- 把上面的
exdemo.cpp编出来跑一遍,记录输出和退出码;再删掉try/catch,用Start-Process -Wait -PassThru拿到退出码(本机实测541541187),观察输出是否为空。 - 在未捕获异常的版本里,把
std::cout换成std::cerr,或者手动flush(),看崩溃前的那行提示是否还能留下。这一步能理解缓冲与 abort 的关系。 - 写一个类,移动构造函数标上
noexcept,再用std::vector装它并反复扩容;对比把noexcept去掉后,扩容时调用的是移动还是拷贝。 - 用
std::expected写一个解析函数,先用-std=c++23编译运行(本机实测可用),再换-std=c++20编译,把报错原文记下来。 - 如果手边有 Linux 环境,装 gdb 和 ASan,对一段越界访问做一次
bt和 ASan 报告;这两步本机未实测。
小结
记住三件事:异常没人接住就走 terminate 加 abort,不会栈展开、不会刷新缓冲,所以现场信息要在抛出点就带上;错误码和异常各管一段,别在同一条调用链上来回翻译;noexcept 是承诺不是提示,标错会让「可恢复的错误」直接变成进程终止。
到这里,单进程内的错误处理已经有了完整路径。但真实的服务很少只有一个执行流:多个线程共享数据、锁的粒度决定吞吐、一个线程崩了会带走整个进程。下一篇讲进程、线程与并发,把「同时发生」这件事带来的新问题摊开。