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

3. 栈展开

抛出异常后，程序暂停当前函数的执行，开始寻找匹配的 catch 子句。首先检查 throw 是否在 try 块内部，如果在则查找匹配的 catch 语句；如果有匹配的，则跳转处理。

如果当前函数中没有 try/catch 子句，或者类型不匹配，则退出当前函数，继续在外层调用函数链中查找。上述查找过程被称为栈展开。

如果到达 main 函数依旧没有找到匹配的 catch 子句，程序会调用标准库的 terminate 函数终止程序。

找到匹配的 catch 子句处理后，代码会继续执行后续逻辑。

4. 查找匹配的处理代码

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

但也存在例外情况，允许以下转换：

• 非常量向常量的类型转换（权限缩小）。
• 数组转换为指向数组元素类型的指针。
• 函数转换为指向函数的指针。
• 派生类向基类类型的转换（这点非常实用，实际继承体系设计基本都基于此）。

如果到 main 函数异常仍未被匹配就会终止程序。为了避免非严重错误导致程序崩溃，通常 main 函数最后会使用 catch(...) 捕获任意类型的异常，但此时无法得知具体的异常内容。

#include <iostream>
#include <string>
#include <thread>
#include <chrono>
#include <cstdlib>
#include <ctime>

// 一般大型项目程序才会使用异常，下面模拟设计服务的几个模块
// 每个模块继承自 Exception 派生类，可以添加自己的数据
// 最后捕获时，捕获基类即可

class Exception {
public:
    Exception(const std::string& errmsg, int id)
        : _errmsg(errmsg), _id(id) {}
    virtual std::string what() const { return _errmsg; }
    int getId() const { return _id; }
protected:
    std::string _errmsg;
    int _id;
};

class SqlException : public Exception {
public:
    SqlException(const std::string& errmsg, int id, const std::string& sql)
        : Exception(errmsg, id), _sql(sql) {}
    virtual std::string what() const {
        std::string str = "SqlException:";
        str += _errmsg;
        str += "->";
        str += _sql;
        return str;
    }
private:
    const std::string _sql;
};

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

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

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

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

void HttpServer() {
    if (rand() % 3 == 0) {
        throw HttpException("请求资源不存在", 100, "get");
    } else if (rand() % 4 == 0) {
        throw HttpException("权限不足", 101, "post");
    } else {
        std::cout << "HttpServer 调用成功" << std::endl;
    }
    CacheMgr();
}

int main() {
    srand(time(0));
    while (true) {
        this_thread::sleep_for(std::chrono::seconds(1));
        try {
            HttpServer();
        } catch (const Exception& e) {
            // 这里捕获基类，基类对象和派生类对象都可以被捕获
            std::cout << e.what() << std::endl;
        } catch (...) {
            std::cout << "Unknown Exception" << std::endl;
        }
    }
    return 0;
}

5. 异常重新抛出

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

// 下面程序模拟聊天发送消息，发送失败补货异常
// 可能在电梯地下室等场景手机信号不好，则需要多次尝试
// 如果多次尝试都发送不出去，则捕获异常再重新抛出
// 其次如果不是网络差导致的错误，捕获后也要重新抛出

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

void SendMsg(const std::string& s) {
    // 发送消息失败，则再重试 3 次
    for (size_t i = 0; i < 4; i++) {
        try {
            _SeedMsg(s);
            break;
        } catch (const Exception& e) {
            // 捕获异常，if 中是 102 号错误，网络不稳定，则重新发送
            // 捕获异常，else 中不是 102 号错误，则将异常重新抛出
            if (e.getId() == 102) {
                // 重试三次以后否失败了，则说明网络太差了，重新抛出异常
                if (i == 3) throw;
                std::cout << "开始第" << i + 1 << "重试" << std::endl;
            } else {
                throw;
            }
        }
    }
}

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

6. 异常安全问题

1. 异常抛出后，后面的代码就不再执行。前面申请了资源（内存、锁等），后面进行释放，但中间可能会抛异常导致资源未释放，引发资源泄漏。 我们需要捕获异常，释放资源后再重新抛出。当然，智能指针章节讲的 RAII 方式解决这种问题是更好的。
2. 其次析构函数中，如果抛出异常也要谨慎处理。比如析构函数要释放 10 个资源，释放到第 5 个时抛出异常，则也需要捕获处理，否则后面的 5 个资源就没释放，造成资源泄漏。《Effective C++》第 8 条款也专门讲了这个问题：别让异常逃离析构函数。

#include <iostream>

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

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

int main() {
    try {
        Func();
    } catch (const char* errmsg) {
        std::cout << errmsg << std::endl;
    } catch (const std::exception& e) {
        std::cout << e.what() << std::endl;
    } catch (...) {
        std::cout << "Unknown Exception" << std::endl;
    }
    return 0;
}

7. 异常规范

1. 对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，有助于简化调用函数的代码。
2. C++98 中函数参数列表后面接 throw()，表示函数不抛异常；接 throw(类型 1，类型 2…) 表示可能会抛出多种类型的异常，用逗号分割。
3. C++98 的方式过于复杂，实践中并不好用。C++11 进行了简化，函数参数列表后面加 noexcept 表示不会抛出异常，啥都不加表示可能会抛出异常。
4. 编译器并不会在编译时检查 noexcept。如果一个函数用 noexcept 修饰了，但又包含了 throw 语句或调用的函数可能会抛出异常，编译器还是会顺利编译通过（有些编译器可能会报个警告）。但是一个声明了 noexcept 的函数抛出了异常，程序会调用 terminate 终止程序。
5. noexcept(expression) 还可以作为一个运算符去检测一个表达式是否会抛出异常，可能会则返回 false，不会就返回 true。

// C++98
// 这里表示这个函数只会抛出 bad_alloc 的异常
void* operator new(std::size_t size) throw(std::bad_alloc);

// 这里表示这个函数不会抛出异常
void* operator delete(std::size_t size, void* ptr) throw();

// C++11
size_type size() const noexcept;
iterator begin() noexcept;
const_iterator begin() const noexcept;

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

int main() {
    try {
        int len, time;
        std::cin >> len >> time;
        std::cout << doubleDivide(len, time) << std::endl;
    } catch (const char* errmsg) {
        std::cout << errmsg << std::endl;
    } catch (...) {
        std::cout << "Unknown Exception" << std::endl;
    }
    int i = 0;
    std::cout << noexcept(Divide(1, 2)) << std::endl;
    std::cout << noexcept(Divide(1, 0)) << std::endl;
    std::cout << noexcept(++i) << std::endl;
    return 0;
}

二、标准库的异常

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

参考文档：https://legacy.cplusplus.com/reference/exception/exception/