异常处理
一句话定义:异常处理让"出错的代码"和"处理错误的代码"分家:出错的地方只管
throw,处理的地方用catch接住。
抓住try/throw/catch三件套,再记住"派生类在前、按引用捕获",日常够用了。
一、为什么需要异常
一个函数发现"算不下去了",得把这个坏消息传给调用它的人。常见有三种传法:
| 方式 | 怎么传 | 缺点 |
|---|---|---|
| 返回错误码 | return -1 |
每个调用处都要 if,一漏就出事;-1 还可能和正常结果撞车 |
| 全局变量 | 设置 errno 再检查 |
忘了检查照样出事 |
| 抛异常 | throw,自动跳到 catch |
有运行开销,要多写几行 |
用返回值写法,错误处理会混进正常流程里:
int r = divide(a, b);
if (r == -1) { /* 出错 */ } // 每个调用点都得写一遍
int s = divide(c, d);
if (s == -1) { /* 又一遍 */ }
用异常,正常流程干干净净,出错的地方集中处理:
try {
cout << divide(a, b) << divide(c, d);
} catch (const exception& e) {
cout << "出错了: " << e.what();
}
💡 类比:异常像火警。平时各干各的,一旦有人按下警铃(
throw),所有人立刻从应急通道(栈展开)退到大楼外的集合点(catch)。
二、三件套:try、throw、catch
2.1 最小完整写法
#include <iostream>
#include <stdexcept>
using namespace std;
double divide(double a, double b) {
if (b == 0) throw runtime_error("除数为 0");
return a / b;
}
int main() {
try {
cout << divide(6, 3) << "\n"; // 2
cout << divide(6, 0) << "\n"; // 这里抛出,后面全跳过
cout << "这行不会执行\n";
} catch (const runtime_error& e) {
cout << "捕获: " << e.what() << "\n"; // 除数为 0
}
return 0;
}
三段各司其职:
| 部分 | 干什么 | 位置 |
|---|---|---|
try { } |
圈出"可能出事"的代码 | 出问题的地方 |
throw 值; |
报告错误并立即中断当前函数 | 出错的那一行 |
catch (类型 e) { } |
接住并处理 | 调用链的上层 |
2.2 throw 可以抛任何东西
throw 42; // 抛整数
throw "文件打不开"; // 抛字符串
throw runtime_error("除零"); // 抛对象(推荐)
但推荐抛标准异常或其派生类——只有它们能被 catch (const exception&) 统一兜住。
2.3 匹配是按"类型"来的
抛出 out_of_range 时,下面这三种写法都能接住:
catch (const out_of_range& e) // 精确匹配
catch (const logic_error& e) // 基类(out_of_range 派生自它)
catch (const exception& e) // 更上层的基类
这一点很关键:catch 按继承关系匹配,不按值比较。
2.4 没人接,程序就终止
如果一路上都没有匹配的 catch,程序会打印一行 terminate called after throwing an instance of 'std::runtime_error',然后直接结束。
terminate called after throwing an instance of 'std::runtime_error'
what(): 没人接
2.5 catch(…) 兜底
try {
// 一堆可能抛各种东西的代码
} catch (...) {
cout << "出了点问题\n"; // 什么都接住,但不知道是什么
}
它适合放在最外层做保险,不适合放在里层——接住之后类型信息就没了。
三、标准异常家族
C++ 标准库已经备好一套异常类,不用自己从零造:
| 类 | 在哪 | 什么时候用 |
|---|---|---|
std::exception |
<exception> |
所有标准异常的基类,what() 取说明 |
std::logic_error |
<stdexcept> |
程序写错了,改代码就能避免 |
std::out_of_range |
<stdexcept> |
下标、参数超出范围 |
std::invalid_argument |
<stdexcept> |
参数的值不合法 |
std::runtime_error |
<stdexcept> |
运行时才知道的错,如除零、文件打不开 |
std::bad_alloc |
<new> |
内存申请失败 |
logic_error 和 runtime_error 的区别很好记:
- logic_error:程序员的锅,改代码就不该再出现;
- runtime_error:环境的锅,同样代码换个输入就可能出错。
标准库自己也在用。比如 vector 的 at() 越界就会抛:
vector<int> v{1, 2, 3};
try {
cout << v.at(5); // 越界
} catch (const out_of_range& e) {
cout << "下标越界了\n";
}
💡
v[5]不检查也不抛,属于未定义行为;v.at(5)会抛out_of_range。要安全检查就用at。
四、自定义异常
业务上的错误,标准库那几种覆盖不到,就自己造一个——继承 runtime_error 最省事:
class InsufficientFunds : public runtime_error {
public:
explicit InsufficientFunds(int n)
: runtime_error("余额不足"), need(n) {}
int need; // 还差多少钱
};
int main() {
try {
throw InsufficientFunds(100);
} catch (const InsufficientFunds& e) {
cout << e.what() << ",还差 " << e.need << " 元\n";
}
}
输出:
余额不足,还差 100 元
继承的好处有三条:
- 自带
what(),一句话说明错在哪; - 能携带自己的数据(上面那个
need); - 能同时被
catch (const InsufficientFunds&)精确接住,也能被catch (const exception&)兜底。
五、栈展开与 RAII
5.1 抛出时,沿途的局部对象会被销毁
struct Resource {
string name;
Resource(string n) : name(n) { cout << " 打开 " << name << "\n"; }
~Resource() { cout << " 关闭 " << name << "\n"; }
};
void inner() {
Resource r("inner 里的资源");
throw runtime_error("inner 出错");
}
void outer() {
Resource r("outer 里的资源");
inner();
}
outer 调用 inner 时抛出,两个函数都没写 catch,但它们的局部对象照样被销毁:
打开 outer 里的资源
打开 inner 里的资源
关闭 inner 里的资源
关闭 outer 里的资源
在 main 捕获: inner 出错
这个过程叫栈展开:异常从内层往外层找 catch,路过的每一层都会正常退出,局部对象按相反顺序析构。
5.2 这就是 RAII 的底气
既然析构一定会执行,那就把资源交给对象管:构造函数里申请,析构函数里释放,中间怎么出错都不漏。
class FileGuard {
public:
FileGuard(const string& path) : f(path) {
if (!f.is_open()) throw runtime_error("打不开 " + path);
}
~FileGuard() { f.close(); } // 无论如何都会关
private:
ofstream f;
};
而下面这种"裸写"就不安全——close 之前抛了异常,文件永远关不上:
ofstream f("out.txt");
f << 算点东西(); // 这里抛异常
f.close(); // 永远执行不到
💡 判断标准:资源有没有"专属的负责人"。有,异常就安全;没有,就靠运气。
六、六个坑
6.1 catch 顺序:基类不能写在前面
try { throw out_of_range("越界"); }
catch (const exception& e) { /* 先写基类 */ } // ❌ 全被它吞掉
catch (const out_of_range& e) { /* 永远到不了 */ }
实测运行只走第一个 catch,编译时还会给警告:
warning: exception of type 'std::out_of_range' will be caught by earlier handler
正确顺序是派生类在前,基类在后。
6.2 按值捕获会"切片"
try { throw MyError(); } // MyError 继承 runtime_error,消息是"我的错误"
catch (exception e) { cout << e.what(); } // 输出 std::exception
catch (const exception& e) { cout << e.what(); } // 输出 我的错误
按值捕获会把派生类对象"切"成基类,自己的信息全丢了。一律按引用捕获(const 引用 最好)。
6.3 析构函数里抛异常
~D() { throw runtime_error("析构抛异常"); } // ❌
C++11 起析构函数默认是 noexcept,在里面抛异常会直接调用 terminate,程序当场结束。编译时也会警告:
warning: 'throw' will always call 'terminate' [-Wterminate]
6.4 noexcept 函数里抛异常
void f() noexcept { throw runtime_error("noexcept 里抛"); } // ❌ terminate
标了 noexcept 就等于承诺"我不抛",违背承诺的下场和上一条一样。
6.5 catch(…) 里要重新抛出
catch (...) {
cout << "出错\n";
throw; // ✔ 原样再抛,让上层处理
}
throw; 不带值,就重新抛出当前这个异常——这是 catch(...) 最常用的收尾方式。
6.6 别用异常做正常流程
异常有开销(要展开栈、构造对象),遍历数组时用 throw 控制循环属于滥用。异常只管"意外",正常分支用 if。
七、自测八题
先自己答,再看右边。
| 题号 | 题目 | 答案 |
|---|---|---|
| 1 | 抛出的异常没有任何 catch 接住,会怎样? |
程序终止,打印 terminate called... |
| 2 | catch (const exception&) 能接住 out_of_range 吗? |
能,按继承关系匹配 |
| 3 | 多个 catch 的子句应该按什么顺序排? |
派生类在前,基类在后 |
| 4 | 按值捕获自定义异常,会丢什么? | 派生类的信息(切片),what() 变基类 |
| 5 | 析构函数里抛异常会怎样? | 调用 terminate,程序终止 |
| 6 | vector 的 at() 越界抛什么? |
std::out_of_range |
| 7 | 函数标了 noexcept 却抛异常? |
调用 terminate |
| 8 | 异常向外传递时,沿途的局部对象会怎样? | 被依次析构(栈展开) |
总结
💡 全文一句话:
throw只管报告,catch按类型接住,中间路过的对象都会被析构——所以资源交给对象管最安全。
- 三件套:
try圈范围、throw报错、catch处理 - 匹配看类型和继承关系:
out_of_range能被logic_error、exception接住 - 自定义异常继承
runtime_error,自带what()还能携带数据 - 栈展开保证局部对象析构,RAII 靠这一点做到异常安全
- 六个坑:catch 顺序、按值捕获、析构里抛、
noexcept里抛、catch(...)不重抛、拿异常当分支
⚠️ 最后一记警钟:异常的错,多半错在"以为接住了"——
catch顺序写反,最该处理的那个子句永远走不到;按值捕获,what()悄悄变成std::exception;析构函数里一抛,程序直接 terminate。写完先打一遍日志,看看到底走了哪个catch。