C++ 异常处理机制详解

被选中的处理代码是调用链中与该对象类型匹配且离抛出位置最近的那一个。如果有多层 catch 且类型相同，就近原则生效。注意类型必须严格匹配。

抛出异常对象后，会生成一个拷贝。因为抛出的可能是局部对象，所以这个拷贝会在 catch 子句执行完毕后销毁。这类似于函数的传值返回。

一旦 throw 执行，其后的语句将不再被执行。控制权从 throw 位置转移到匹配的 catch 位置。这里有两个关键点：

1. 沿着调用链的函数可能提早退出。
2. 一旦进入异常处理程序，沿着调用链创建的对象都将销毁（栈展开）。

三、栈展开

抛出异常后，程序暂停当前函数的执行，开始寻找匹配的 catch 子句。首先检查 throw 是否在 try 块内部，如果有则查找；如果没有或类型不匹配，则退出当前函数，继续在外层调用链中查找。这个过程被称为栈展开。

如果到达 main 函数依旧没有找到匹配的 catch，程序会调用标准库的 terminate 函数中止。如果找到并处理了，catch 之后的代码会继续执行。

四、查找匹配的处理代码

一般情况下，抛出对象和 catch 是类型完全匹配的。如果有多个匹配，选择离抛出点更近的那个。

如果在 main 函数仍未匹配，程序终止。为了避免非严重错误导致程序崩溃，通常建议在 main 函数最后使用 catch(...) 捕获任意类型的异常，虽然此时无法得知具体错误信息。

int main() {
    while (1) {
        try {
            func();
        } catch (const string& errmsg) {
            cout << errmsg << endl;
        } catch (...) {
            cout << "Unknown Exception" << endl;
        }
    }
    return 0;
}

此外，存在类型转换规则：允许非常量向常量转换（权限缩小）、数组转指针、派生类转基类。实际项目中常利用继承体系，通过捕获基类异常来处理所有派生类异常。

下面模拟设计一个服务模块，每个模块继承自 Exception 基类：

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
#include <thread>
#include <chrono>
using namespace std;

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) {}
    virtual string what() const {
        string str = "SqlException:";
        str += _errmsg;
        str += "->";
        str += _sql;
        return str;
    }
private:
    const string _sql;
};

class CacheException : public Exception {
public:
    CacheException(const string& errmsg, int id) : Exception(errmsg, id) {}
    virtual string what() const {
        string str = "CacheException:";
        str += _errmsg;
        return str;
    }
};

class HttpException : public Exception {
public:
    HttpException(const string& errmsg, int id, const string& type)
        : Exception(errmsg, id), _type(type) {}
    virtual string what() const {
        string str = "HttpException:";
        str += _type;
        str += ":";
        str += _errmsg;
        return str;
    }
private:
    const string _type;
};

void SQLMgr() {
    if (rand() % 7 == 0) {
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    } else {
        cout << "SQLMgr 调用成功" << endl;
    }
}

void CacheMgr() {
    if (rand() % 5 == 0) {
        throw CacheException("权限不足", 100);
    } else if (rand() % 6 == 0) {
        throw CacheException("数据不存在", 101);
    } else {
        cout << "CacheMgr 调用成功" << endl;
    }
    SQLMgr();
}

void HttpServer() {
    if (rand() % 3 == 0) {
        throw HttpException("请求资源不存在", 100, "get");
    } else if (rand() % 4 == 0) {
        throw HttpException("权限不足", 101, "post");
    } else {
        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;
        }
    }
    return 0;
}

五、异常重新抛出

有时我们需要对捕获的异常进行分类。某些特定错误需要特殊处理，而其他错误则应继续向上层传递。捕获后若需重新抛出，直接使用 throw; 即可把当前对象原样抛出。

例如聊天发送消息场景：网络不稳定导致的失败可以重试，但如果是对方不是好友这种逻辑错误，重试也无用，应直接抛出。

void _SeedMsg(const string& s) {
    if (rand() % 2 == 0) {
        throw HttpException("网络不稳定，发送失败", 102, "put");
    } else if (rand() % 7 == 0) {
        throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
    } else {
        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;
            }
        }
    }
}

int main() {
    srand(time(0));
    string str;
    while (cin >> str) {
        try {
            SendMsg(str);
        } catch (const Exception& e) {
            cout << e.what() << endl << endl;
        } catch (...) {
            cout << "Unknown Exception" << endl;
        }
    }
    return 0;
}

六、异常安全问题

异常抛出后，后续代码不再执行。如果之前申请了资源（内存、锁等），中间发生异常可能导致资源未释放，从而引发泄漏。

解决思路有两种：

1. 在 catch 块中手动释放资源后再重新抛出。
2. 使用 RAII（资源获取即初始化）机制，如智能指针，这是更推荐的方式。

另外，析构函数中抛出异常也要谨慎。如果析构函数释放 10 个资源，在第 5 个时抛出异常，剩下的 5 个将无法释放。《Effective C++》第 8 条款专门强调：别让异常逃离析构函数。

七、noexcept

预先知道某个函数是否会抛出异常，对编译器和调用者都有利，有助于简化代码和优化性能。

• C++98：使用 throw() 表示不抛异常，throw(Type1, Type2...) 表示可能抛出多种类型。这种方式过于复杂，实践中较少使用。
• C++11：引入 noexcept 修饰符。函数参数列表后加 noexcept 表示不会抛出异常，不加则表示可能抛出。

编译器不会在编译时强制检查 noexcept 内的逻辑是否真的不抛异常。如果一个声明为 noexcept 的函数最终抛出了异常，程序会调用 terminate 终止。

此外，noexcept(expression) 可作为运算符检测表达式是否会抛出异常，返回 true 或 false。