C++ 异常处理：理论、栈展开与最佳实践

2.3.2 最佳实践

2.4 异常重新抛出

2.4.1 概念

有时 catch 到一个异常对象后，需要对错误进行分类，其中的某种异常错误需要进行特殊的处理，其他错误则重新抛出异常给外层调用链处理。捕获异常后需要重新抛出，直接 throw；就可以把捕获的对象直接拋出。

2.4.2 最佳实践

2.5 异常安全问题

2.5.1 注意事项

1. 异常抛出后，后面的代码就不再执行，前面申请了资源（内存、锁等），后面进行释放，但是中间可能会抛异常就会导致资源没有释放，这里由于异常就引发了资源泄漏，产生安全性的问题。中间我们需要捕获异常，释放资源后面再重新抛出，当然后面智能指针章节讲的 RAII 方式解决这种问题是更好的。

2. 其次析构函数中，如果抛出异常也要谨慎处理，比如析构函数要释放 10 个资源，释放到第 5 个时抛出异常，则也需要捕获处理，否则后面的 5 个资源就没释放，也资源泄漏了。《EffectiveC++》中的第 8 个条款也专门讲了这个问题，别让异常逃离析构函数。

2.5.2 最佳实践

2.6 异常规范

2.6.1 理论

对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，知道某个函数是否会抛出异常有助于简化调用函数的代码。

C++98 中函数参数列表的后面接 throw)，表示函数不抛异常，函数参数列表的后面接 throw(类型 1，类型 2…) 表示可能会抛出多种类型的异常，可能会抛出的类型用逗号分割。

C++98 的方式这种方式过于复杂，实践中并不好用，C++11 中进行了简化，函数参数列表后面加 noexcept 表示不会抛出异常，啥都不加表示可能会抛出异常。

编译器并不会在编译时检查 noekcept，也就是说如果一个函数用 noexcept 修饰了，但是同时又包含了 throw 语句或者调用的函数可能会抛出异常，编译器还是会顺利编译通过的（有些编译器可能会报个警告）。但是一个声明了 noexcept 的函数抛出了异常，程序会调用 terminate 终止程序。

noexcept(expression) 还可以作为一个运算符去检测一个表达式是否会抛出异常，可能会则返回 false，不会就返回 true。

2.6.2 最佳实践

3 ~> 标准库的异常

标准库链接： std::exception

C++ 标准库也定义了一套自己的一套异常继承体系库，基类是 exception，其它的都是它的派生类，所以我们日常写程序，需要在主函数捕获 exception 即可，要获取异常信息，调用 what 函数，what 是一个虚函数，派生类可以重写。

C++11 完整代码示例与实践演示

Test.cpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <exception>
#include <thread>
#include <chrono>

using namespace std;

// 延时功能
// 一般大型项目才会使用异常，下面我们模拟设计一个服务的几个模块
// 每个模块的继承都是 Exception 的派生类，每个模块可以添加自己的数据
// 最后捕获时，我们捕获基类即可
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 HttpSever() {
    if (rand() % 3 == 0) {
        throw HttpException("申请资源不存在", 100, "get");
    } else if (rand() % 4 == 0) {
        throw HttpException("权限不足", 101, "post");
    } else {
        cout << "HttpSever 调用成功" << endl;
    }
    CacheMgr();
}

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

// 网络不稳定，要求重试 3 次，均失败
void SendMsg(const string& s) {
    for (size_t i = 0; i < 4; i++) {
        try {
            _Sending(s); // 走到这里代表成功了，跳出循环
            break;
        } catch (const Exception& e) {
            if (e.getid() == 102) {
                if (i == 3) throw;
                cout << "开始第" << i + 1 << "重试" << endl;
            } else {
                // 重新抛出异常
                throw;
            }
        }
    }
}

double Divide(int a, int b) noexcept {
    // 当 b == 0 时抛出异常
    if (b == 0) {
        throw "Division by zero condition!";
    }
    return (double)a / (double)b;
}

void Func() {
    // 这里可以看出如果发生除 0 错误抛出异常，另外下面的 array 没有得到释放
    // 所以这里捕获异常后并不处理异常，异常还是交给外层处理，这里捕获了再重新抛出去
    int* array = new int[10];
    int len, time;
    try {
        cout << Divide(len, time) << endl;
    } catch (...) {
        cout << "delete []" << array << endl;
        delete[] array;
        // 重新抛出，捕获到什么就抛出什么
        throw;
    }
    cout << "delete[]" << array << endl;
    delete[] array;
}

int main() {
    srand(time(0));
    while (1) {
        this_thread::sleep_for(chrono::seconds(1)); // 延迟 1 秒
        try {
            HttpSever();
        } catch (const Exception& e) { // 这里捕获基类，基类对象和派生类对象都可以被捕获
            // 多态调用
            cout << e.what() << endl;
        } catch (...) { // 任意类型的对象
            cout << "Unknown Exception" << endl;
        }
    }
    return 0;
}

输出结果示例：

HttpSever 调用成功
CacheMgr 调用成功
SQLMgr 调用成功
...
HttpException：get : 申请资源不存在
...

void SendMsg(const string& s) { for (size_t i = 0; i < 4; i++) { try { _Sending(s); break; } catch (const Exception& e) { if (e.getid() == 102) { if (i == 3) throw; cout << "开始第" << i + 1 << "重试" << endl; } else { throw; } } } }

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

void Func() { int* array = new int[10]; int len, time; try { cout << Divide(len, time) << endl; } catch (...) { cout << "delete []" << array << endl; delete[] array; throw; } cout << "delete[]" << array << endl; delete[] array; }

int main() { int i = 0; cout << noexcept(Divide(1, 2)) << endl; cout << noexcept(Divide(1, 0)) << endl; cout << noexcept(Func()) << endl; cout << noexcept(++i) << endl; return 0; }

// 输出结果： // 0 // 0 // 0 // 1