异常处理

一句话定义:异常处理让"出错的代码"和"处理错误的代码"分家:出错的地方只管 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 元

继承的好处有三条:

  1. 自带 what(),一句话说明错在哪;
  2. 能携带自己的数据(上面那个 need);
  3. 能同时被 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。


本站由 奇迹欧埃 使用 Stellar 创建。