C++异常传播的基础流程
C++的异常传播是指当程序中使用throw语句抛出某个异常对象后，运行时会沿着函数调用栈向上查找匹配的catch子句，直到找到能够处理该异常的逻辑，这个查找和传递的过程就是异常传播。如果整个调用栈都没有找到匹配的catch子句，程序会调用std::terminate终止运行。
异常传播的核心触发点是throw语句，抛出的异常可以是任意类型的对象，比如内置类型、自定义结构体或者标准库异常类型。当throw执行后，当前函数的后续代码会立即停止执行，进入传播查找流程。
基础传播示例
下面的代码展示了最简单的异常传播过程，在func2中抛出异常，在main函数的catch子句中捕获：
#include <iostream>
#include <stdexcept>
// 定义自定义异常类型
struct MyException : public std::runtime_error {
MyException(const std::string& msg) : std::runtime_error(msg) {}
};
void func2() {
// 抛出自定义异常对象
throw MyException("func2执行出错");
}
void func1() {
func2(); // 调用func2，func2抛出异常后会直接跳转到main的catch
std::cout << "func1后续代码不会执行" << std::endl;
}
int main() {
try {
func1();
std::cout << "main try块后续代码不会执行" << std::endl;
} catch (const MyException& e) {
// 捕获到传播的异常，输出异常信息
std::cout << "捕获到异常：" << e.what() << std::endl;
} catch (const std::exception& e) {
std::cout << "捕获到标准异常：" << e.what() << std::endl;
}
return 0;
}
上述代码执行后，func2抛出异常后，func1和main try块中throw之后的代码都不会执行，最终异常被main中的第一个catch子句捕获，输出对应的错误信息。
栈展开与资源释放规则
异常传播过程中，从抛出点到捕获点之间的所有栈上对象都会被自动销毁，这个过程叫做栈展开。栈展开的顺序和函数调用顺序相反，先销毁抛出点所在函数的局部对象，再销毁上一层调用函数的局部对象，依次向上直到捕获异常的函数。
栈展开的资源释放验证
下面的代码通过自定义类型的析构函数输出信息，验证栈展开时的对象销毁顺序：
#include <iostream>
#include <stdexcept>
struct Resource {
int id;
Resource(int i) : id(i) {
std::cout << "Resource " << id << " 构造" << std::endl;
}
~Resource() {
std::cout << "Resource " << id << " 析构" << std::endl;
}
};
void inner_func() {
Resource r2(2); // 内层函数局部对象
throw std::runtime_error("inner_func出错"); // 抛出异常，触发栈展开
std::cout << "inner_func后续代码" << std::endl;
}
void outer_func() {
Resource r1(1); // 外层函数局部对象
inner_func();
std::cout << "outer_func后续代码" << std::endl;
}
int main() {
try {
outer_func();
} catch (const std::exception& e) {
std::cout << "捕获异常：" << e.what() << std::endl;
}
return 0;
}
执行上述代码会输出：
- Resource 1 构造
- Resource 2 构造
- Resource 2 析构
- Resource 1 析构
- 捕获异常：inner_func出错
可以看到栈展开时先销毁了inner_func的r2，再销毁了outer_func的r1，符合栈的后进先出规则。如果局部对象是动态分配的堆内存，栈展开不会自动释放堆内存，这也是为什么建议使用智能指针管理动态资源的原因。
异常重新抛出机制
有时候catch子句捕获到异常后，无法完全处理该异常，需要让异常继续向上传播，这时候可以使用不带表达式的throw语句重新抛出当前异常。重新抛出的异常会保持原有的类型和状态，继续向上查找匹配的catch子句。
异常重新抛出示例
下面的代码展示了异常重新抛出的使用场景，中间层捕获异常后做部分处理，再重新抛出给上层：
#include <iostream>
#include <stdexcept>
void core_func() {
throw std::runtime_error("核心逻辑出错");
}
void middle_func() {
try {
core_func();
} catch (const std::exception& e) {
std::cout << "middle_func记录异常日志：" << e.what() << std::endl;
throw; // 重新抛出当前异常，继续向上传播
}
}
int main() {
try {
middle_func();
} catch (const std::exception& e) {
std::cout << "main处理异常：" << e.what() << std::endl;
}
return 0;
}
执行后输出：
- middle_func记录异常日志：核心逻辑出错
- main处理异常：核心逻辑出错
需要注意，重新抛出的throw语句必须放在catch子句内部，否则没有可重新抛出的异常对象，会导致未定义行为。
异常传播的常见注意事项
在使用C++异常传播机制时，有几个常见的注意点需要关注：
- 不要在析构函数中抛出异常，因为如果在栈展开过程中析构函数抛出异常，会导致程序调用std::terminate终止，C++11之后析构函数默认是noexcept的，抛出异常的析构函数需要显式标记为noexcept(false)。
- 捕获异常时建议使用const引用接收异常对象，避免不必要的拷贝，同时可以匹配到派生类的异常对象，符合异常类型的继承体系匹配规则。
- 如果抛出的异常是局部对象的指针，传播过程中该局部对象会被销毁，捕获到的指针会变成悬空指针，因此不建议抛出指向局部对象的指针，尽量抛出对象本身或者智能指针。
下面的代码展示了抛出局部对象指针的错误用法：
#include <iostream>
#include <stdexcept>
void bad_func() {
std::runtime_error e("错误");
throw &e; // 抛出局部对象的指针，e会在函数退出时销毁
}
int main() {
try {
bad_func();
} catch (std::runtime_error* e) {
// e已经是悬空指针，访问行为未定义
std::cout << e->what() << std::endl;
}
return 0;
}
这种写法存在严重的风险，实际开发中应当避免。