C++ 异常：从基础用法到避不开的坑

运行时，divide 抛出 string 异常，首先在 divide 自己的 catch (int) 处不匹配；然后退回到 func 中的 try 块，func 的 catch (const char*) 也不匹配；最后在 main 中被 catch (string&) 捕获。这期间，从 throw 到 main 的 catch 之间的所有语句都会被跳过（包括 func 中的 cout 和 catch 块）。

如果异常在中间某一层被匹配到了，栈展开就会停止，该层 catch 之后的代码会继续执行，上层函数完全不受影响。例如，让 func 增加一个 catch (const char*) 就能在 func 内处理掉异常，main 中就不会再捕获到，整个过程照常结束。

匹配规则与继承体系

通常要求抛出的对象类型与 catch 声明的类型精确匹配，但有一些合理的隐式转换允许发生：

• 非常量到常量的转换（权限缩小）
• 数组或函数向指针的转换（decay）
• 派生类向基类的转换 —— 这条在项目里非常有用

利用继承体系，我们可以将异常设计为基类 Exception，派生出 SqlException、CacheException、HttpException 等，用基类引用 catch (const Exception& e) 统一捕获，再通过虚函数获取具体错误信息。这是实际工程中常见的手法。

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 { /* ... */ };
class CacheException : public Exception { /* ... */ };
class HttpException : public Exception { /* ... */ };

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) {
        try {
            HttpServer();
        } catch (const Exception& e) {
            cout << e.what() << endl; // 多态调用
        } catch (...) {
            cout << "未知异常" << endl;
        }
    }
    return 0;
}

同时，catch(...) 可以充当最后一道防线，捕获所有类型的异常，但你看不到具体信息。如果一直没人接住异常，程序直接终止，这通常不是我们想要的。

异常重新抛出

有时候，你 catch 到了一个异常，但只能处理其中一部分情况，剩下的仍然需要向上传播。直接 throw; 即可把当前捕获的异常原样再抛出去，方便分层处理。

void _SeedMsg(const string& s) {
    if (rand() % 2 == 0)
        throw HttpException("网络不稳定，发送失败", 102, "put");
    else if (rand() % 7 == 0)
        throw HttpException("已经不是好友", 103, "put");
    cout << "发送成功" << endl;
}

void SendMsg(const string& s) {
    for (size_t i = 0; i < 4; i++) {
        try {
            _SeedMsg(s);
            break;
        } catch (const Exception& e) {
            if (e.getid() == 102) {
                // 网络错误，重试
                if (i == 3) throw; // 三次都失败，往外抛
                cout << "开始第" << i+1 << "次重试" << endl;
            } else {
                throw; // 非重试类错误，直接上抛
            }
        }
    }
}

这里 throw; 不带参数，会把当前捕获的异常原封不动地向上抛出，保留了原来的类型和信息。

资源安全与析构

异常一旦抛出，后面的代码就不会执行了，这很容易导致资源泄漏。典型场景：在函数里 new 了数组，中间可能抛出异常，如果没在 catch 里 delete[] 就直接上抛，那块内存就丢了。

double Divide(int a, int b) {
    if (b == 0) throw "Divide by zero condition";
    return (double)a / (double)b;
}

void func() {
    int* arr = new int[10];
    int a, b;
    cin >> a >> b;
    cout << Divide(a, b) << endl;
    try {
        // ...
    } catch (...) {
        cout << "delete[]" << endl;
        delete[] arr;
        throw;
    }
    // 正常路径也要释放
    cout << "delete[]" << endl;
    delete[] arr;
}

这种手动管理资源的方式很容易出错，用 RAII（如智能指针）可以省心很多。另外，在析构函数内部也要小心，如果析构函数本来要释放一系列资源，中途抛出异常，后面的资源就漏掉了。通常建议析构函数不要抛出异常，如果实在无法避免，就在内部消化掉。

noexcept 规范

C++11 开始，可以用 noexcept 标记一个函数不抛出异常。这只是一种承诺，编译期不会强制检查，但如果一个声明了 noexcept 的函数真的抛出了异常，程序会直接 terminate。

noexcept 还可以作为运算符使用：noexcept(expr) 返回 true 表示表达式不会抛出异常，可用于模板元编程等场景。

对于用户和编译器来说，知道哪些函数可能抛出异常有助于生成更优的代码，也让调用者更容易决策。

以上梳理了 C++ 异常处理的核心机制与常见坑点。合理使用异常，注意资源管理和继承设计，可以写出更健壮的代码。