C++异常机制：抛出、捕获与栈展开

C++的异常机制说复杂不复杂，说简单也藏着不少细节。它本质上是通过 throw（抛出）、try/catch（捕获）和栈展开（Stack Unwinding）这三驾马车，来实现一种结构化的错误处理。其核心思路就两个：一是把“发现错误”和“处理错误”的代码彻底分开，二是利用栈展开自动完成资源清理。

说起来，C语言那一套，基本靠错误码。函数返回一个int，调用方得去查错误码表，麻烦不说，业务逻辑和错误处理的代码常常搅成一锅粥。C++异常机制则提供了一个更优雅的方案：出错的模块只管抛出异常，至于后续怎么擦屁股，由调用链上合适的捕获点去操心，两边互不侵入，代码清爽不少。

这篇文章就来把异常机制的几个关键环节——抛出、捕获、栈展开以及类型匹配规则——掰开揉碎了聊聊，最后用一个实际项目中常见的自定义异常体系，看看怎么落地。

1. 抛出与捕获的基本姿势

1.1 throw干了什么

当程序运行到 throw 语句时，它会立刻构造一个异常对象。紧接着，当前函数里 throw 之后的代码就不执行了，控制权开始沿着调用链向上转移，去寻找匹配的 catch。这个过程有三个关键点需要注意：

• throw 后面的语句直接被跳过。
• 当前函数可能会非正常提前退出。
• 所有在 throw 之前已经构造好的局部对象，会按照构造顺序的逆序进行析构（这个动作由栈展开来完成）。

还有个细节：如果 throw 出去的是一个局部对象，编译器会生成一份拷贝用于传播，原始对象则在栈展开的过程中被销毁。这份拷贝会一直存活到对应的 catch 块处理完毕。

1.2 try/catch怎么接

void Func() {
    int len, time;
    cin >> len >> time;
    try {
        cout << Divide(len, time) << endl;
    } catch (const char* errmsg) {
        cout << errmsg << endl;
    }
    cout << "Func continuing..." << endl;
}
double Divide(int a, int b) {
    if (b == 0) {
        string s("Divide by zero condition!");
        throw s;
    }
    return (double)a / (double)b;
}

看上面这个例子。Divide 里抛出的是一个 string 对象，而 Func 里 catch 的类型是 const char*，这俩对不上。所以 Func 的 catch 会被跳过，异常继续向上传播，去找外层的调用者（比如 main）是否有 catch(string)。如果 main 也找不到，程序就只能调用 std::terminate() 终止了。

关于 catch 的匹配规则，有几个要点：

• 一般情况下要求类型完全匹配。
• 允许从非常量向常量的转换（权限缩小），但不允许其他隐式类型转换（比如 int 转 double）。
• 数组类型会退化为指向其元素的指针，函数类型会退化为函数指针。
• 最关键的一条：支持派生类对象向它的基类类型进行匹配。这个特性在实际工程中非常实用，后面我们会专门讲。

如果所有外层的 catch 都没匹配上，通常会在 main 函数最后写一个 catch(...) 作为万能兜底，防止程序直接崩溃。但它的代价是无法获取任何具体的错误信息。

2. 栈展开：异常的传播路径

栈展开（stack unwinding）是理解异常行为最核心的部分。从 throw 被触发开始，编译器会沿着调用栈执行以下查找流程：

• 首先检查 throw 语句本身是否位于一个 try 块内部。如果是，就看当前 try 块附带的 catch 有没有能匹配的。
• 一旦找到匹配的 catch，控制权就会跳转到那里，然后从这个 catch 块结束后的第一条语句继续往下执行。
• 如果当前函数内没有匹配的 catch，那么当前函数会退出。退出前，该函数所有已构造的局部对象会按逆序析构。之后，控制权回到调用方函数中发起调用的那个位置，重复第一步的查找过程。
• 这个过程一直持续到 main 函数。如果到了 main 还没匹配上，就触发 std::terminate()，程序结束。

假设调用链是 main() → func3() → func2() → func1()，而 func1 抛出的异常直到 main 里才被捕获。那么栈展开会依次退出 func1、func2、func3 的栈帧，每退出一层，就析构掉那一层里所有的局部对象，直到在 main 中找到匹配的 catch。这里说的“退出”不是简单的跳转，它会保证RAII资源（比如锁、智能指针、内存）被正确释放。当然，前提是析构函数本身不能抛出异常，否则会立刻触发 terminate。

3. 自定义异常体系：利用派生类到基类的转换

在实际的项目里，很少会到处抛 string 或者内置类型。更常见的做法是构建一个异常类体系。基类可以是 std::exception，也可以是项目自己定义的基类，然后各个模块继承并派生出自己的异常类型。捕获的时候，只需要捕获基类的引用，就能用一个 catch 统一处理所有模块的异常。

// 基类
class Exception {
public:
    Exception(const string& errmsg, int id)
        : _errmsg(errmsg), _id(id) {}
    virtual string what() const { return _errmsg; }
    int getid() const { return _id; }
protected:
    string _errmsg;
    int _id;
};
// 各模块派生自己的异常
class SqlException : public Exception {
public:
    SqlException(const string& errmsg, int id, const string& sql)
        : Exception(errmsg, id), _sql(sql) {}
    string what() const override {
        return "SqlException:" + _errmsg + "->" + _sql;
    }
private:
    string _sql;
};
class CacheException : public Exception {
public:
    CacheException(const string& errmsg, int id)
        : Exception(errmsg, id) {}
    string what() const override {
        return "CacheException:" + _errmsg;
    }
};
class HttpException : public Exception {
public:
    HttpException(const string& errmsg, int id, const string& type)
        : Exception(errmsg, id), _type(type) {}
    string what() const override {
        return "HttpException:" + _type + ":" + _errmsg;
    }
private:
    string _type;
};

业务函数模拟抛出各类异常：

void SQLMgr() {
    if (rand() % 7 == 0)
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    cout << "SQLMgr 调用成功" << endl;
}
void CacheMgr() {
    if (rand() % 5 == 0)
        throw CacheException("权限不足", 100);
    else if (rand() % 6 == 0)
        throw CacheException("数据不存在", 101);
    cout << "CacheMgr 调用成功" << endl;
    SQLMgr();
}
void HttpServer() {
    if (rand() % 3 == 0)
        throw HttpException("请求资源不存在", 100, "get");
    else if (rand() % 4 == 0)
        throw HttpException("权限不足", 101, "post");
    cout << "HttpServer调用成功" << endl;
    CacheMgr();
}

主函数里只需要捕获基类引用：

int main() {
    srand(time(0));
    while (1) {
        this_thread::sleep_for(chrono::seconds(1));
        try {
            HttpServer();
        } catch (const Exception& e) {
            cout << e.what() << endl;
        } catch (...) {
            cout << "Unknown Exception" << endl;
        }
    }
}

看到这里，好处就很明显了。通过捕获基类引用，配合虚函数 what()，一个 catch 就能精准处理所有派生类的异常，不仅拿到了具体的错误信息，还避免了写一堆分支类型的 catch 子句。日后如果新增一个模块的异常，只要继承 Exception 并重写 what()，上层的捕获代码完全不用改动。这正是开放-封闭原则在错误处理中的一个漂亮体现。

这里有个小坑需要提一下：catch 的参数务必使用引用。如果写成值传递，会发生对象切片，派生类中特有的信息（比如 _sql、_type）就会被无情地丢弃掉。

小结

异常机制的本质，是把错误检测和错误处理这两件事解耦。它的代价是引入了栈展开带来的控制流复杂性和资源管理上的风险。顺着这个思路，下一篇文章会聊聊异常重新抛出、异常安全问题，以及 C++11 引入的 noexcept 规范——它们试图解决的，正是“异常本身带来的问题”。