011-C++之异常

C++之异常

1. C语言传统处理错误的方式

终止程序：如assert、exit，发生错误直接终止程序，缺陷：用户难以接受。
返回错误码：如系统的很多库的接口都是通过把错误码放到errno中表示错误，缺陷：需要自己去查询这些错误码分别代表什么意思。

实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

2. C++异常概念及语法

异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。

语法：

cpp 复制代码

try {
    // 可能抛出异常的代码
    // ...
    if (错误条件) {
        throw 异常对象; // 抛出异常
    }
    // ...
} catch (异常类型1& e) {
    // 处理类型1的异常
    // ...
} catch (异常类型2& e) {
    // 处理类型2的异常
    // ...
} catch (...) {
    // 捕获所有其他类型的异常
    // ...
}

throw ：用于抛出一个异常。当检测到错误时，使用 throw 关键字抛出一个对象（可以是任何类型，但通常使用标准库异常类或自定义异常类）。
try ：用于包裹可能抛出异常的代码块。try 块后面必须紧跟一个或多个 catch 块。
catch ：用于捕获并处理 异常。它捕获 try 块中抛出的异常，并执行相应的错误处理代码。

3. 异常的使用

3.1 异常的抛出与捕获

3.1.1 异常的抛出与匹配原则

异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。
catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。
实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获。

3.1.2 在函数调用链中异常栈展开匹配原则

首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则跳到catch的地方进行处理。
没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
如果到达main函数的栈，依旧没有匹配的，则终止程序。
上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。
找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

测试代码：

cpp 复制代码

#include <iostream>
#include <stdexcept>

double divide(double a, double b) {
    if (b == 0.0) {
        // 抛出标准异常
        throw std::invalid_argument("除数不能为零！");
    }
    return a / b;
}

int main() {
    try {
        double result = divide(10.0, 0.0);
        std::cout << "结果是: " << result << std::endl;
    }
    catch (const std::invalid_argument& e) {
        std::cerr << "捕获到异常: " << e.what() << std::endl;
    }
    return 0;
}

3.2 异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。

测试代码：

cpp 复制代码

#include <iostream>
#include <stdexcept>

void processFile() {
    try {
        // 模拟文件处理中的异常
        throw std::runtime_error("文件读取失败：权限不足");
    }
    catch (const std::exception& e) {
        // 进行一些本地处理（如记录日志）
        std::cerr << "【日志】processFile 中捕获异常: " << e.what() << std::endl;

        // 重新抛出，让调用者处理
        throw; // 重新抛出同一个 std::runtime_error 异常
    }
}

int main() {
    try {
        processFile();
    }
    catch (const std::exception& e) {
        // 最终处理
        std::cerr << "【最终处理】main 中捕获异常: " << e.what() << std::endl;
    }
    return 0;
}

3.3 异常安全

构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化。
析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏（内存泄漏、句柄未关闭等）。
C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于这里的RAII我们在后面的智能指针章节进行介绍。

3.4 异常规范

异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
函数的后面接throw()，表示函数不抛异常，C++11中新增noexcept，接在函数后面也代表不会抛出异常。
若无异常接口声明，则此函数可以抛掷任何类型的异常。

cpp 复制代码

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出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 中新增的noexcept，表示不会抛异常

thread() noexcept;
thread(thread&& x) noexcept;

4. 自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。

5. C++标准库的异常体系

C++ 标准库在 <stdexcept> 头文件中定义了一套常用的异常类，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示（部分）：

下面是对C++11中的异常类的说明：

5.1 根类：`std::exception`

头文件 ：<exception>
描述：所有标准异常的基类。它定义了核心接口 what()，用于获取异常描述字符串。
使用场景 ：通常不直接抛出，而是作为捕获所有标准异常的基类使用（catch (const std::exception& e)）。

5.2 逻辑错误类 (`std::logic_error`)

逻辑错误 通常表示程序内部的逻辑错误，这些错误理论上可以通过更好的代码设计来避免。它们通常在程序运行的早期阶段就会被发现。

5.2.1 `std::invalid_argument`

描述：传递给函数的参数无效。
示例：std::stoi 解析一个非数字字符串时抛出。

5.2.2 `std::domain_error`

描述：参数对于函数的数学定义域无效。
示例：std::sqrt 的参数为负数（在实数域中无效）。

5.2.3 `std::length_error`

描述：尝试创建一个长度超出最大允许值的容器（如 std::string, std::vector）。
示例：std::string 构造函数请求的大小超出 max_size()。

5.2.4 `std::out_of_range`

描述：访问超出范围的元素。
示例：使用 std::vector::at() 访问一个越界的索引。

5.3 运行时错误类 (`std::runtime_error`)

运行时错误 表示在程序运行时发生的、难以通过静态代码分析预测的错误。它们通常与外部环境或运行时状态有关。

5.3.1 `std::overflow_error`

描述：算术运算发生上溢。
示例：std::numeric_limits 相关的计算超出最大值。

5.3.2 `std::underflow_error`

描述：算术运算发生下溢（通常指浮点数运算中结果过小）。
示例：计算一个极小的浮点数导致精度损失。

5.3.3 `std::system_error`

头文件 ：<system_error>
描述：与底层操作系统或系统库相关的错误。
使用场景 ：通常由标准库函数（如文件操作、线程、网络）抛出，携带一个 std::error_code 对象，提供详细的错误信息（如系统错误码和类别）。
示例：std::thread 构造函数失败（资源不足）。

5.3.4 `std::ios_base::failure`

头文件 ：<ios>
描述：输入/输出流操作失败。
注意：它派生自 std::exception，不是 std::runtime_error 的子类。
示例：std::ifstream 打开文件失败，或 std::cin 输入操作失败。

5.4 其他重要异常类

5.4.1 `std::bad_alloc`

头文件 ：<new>
描述：内存分配失败（new 操作符抛出）。
使用场景 ：在内存不足时，new 会抛出此异常（而非返回 nullptr）。

5.4.2 `std::bad_cast`

头文件 ：<typeinfo>
描述：dynamic_cast 转换失败（尝试向下转换为不兼容的类型）。
示例：dynamic_cast<Derived*>(base_ptr) 当 base_ptr 实际指向 Base 对象时抛出。

5.4.3 `std::bad_typeid`

头文件 ：<typeinfo>
描述：对空指针执行 typeid 操作（且该指针未使用 dynamic_cast 检查）。
示例：typeid(*nullptr)。

5.4.4 `std::bad_exception`

头文件 ：<exception>
描述：当异常处理期间发生另一个异常时抛出（通常与 std::unexpected() 机制相关，现代C++中较少见）。

5.4.5 `std::bad_function_call`

头文件 ：<functional>
描述：调用一个空的 std::function 或 std::packaged_task。

5.4.6 `std::bad_optional_access`

头文件 ：<optional>
描述：访问一个不包含值的 std::optional 对象（通过 value() 方法）。

5.4.7 `std::bad_variant_access`

头文件 ：<variant>
描述：访问 std::variant 中当前未持有的成员（通过 get() 或 value() 方法）。

5.4.8 `std::bad_any_cast`

头文件 ：<any>
描述：对 std::any 进行错误的类型转换。

5.4.9 `std::filesystem::filesystem_error`

头文件 ：<filesystem>
描述：文件系统操作失败（如文件不存在、权限不足）。
注意：这是C++17引入的专用异常。

【说明】实际中我们可以可以去继承exception类实现自己的异常类。

6. 异常的优缺点

6.1 异常的优点

异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，而使用异常可以直接跳到catch捕获的地方进行处理。
很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。
部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

6.2异常的缺点

异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个可以使用RAII来处理资源的管理问题。
C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用func() throw()的方式规范化。

【总结】异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。

C++之异常

1. C语言传统处理错误的方式

2. C++异常概念及语法

3. 异常的使用

3.1 异常的抛出与捕获

3.1.1 异常的抛出与匹配原则

3.1.2 在函数调用链中异常栈展开匹配原则

3.2 异常的重新抛出

3.3 异常安全

3.4 异常规范

4. 自定义异常体系

5. C++标准库的异常体系

5.1 根类：std::exception

5.2 逻辑错误类 (std::logic_error)

5.2.1 std::invalid_argument

5.2.2 std::domain_error

5.2.3 std::length_error

5.2.4 std::out_of_range

5.3 运行时错误类 (std::runtime_error)

5.3.1 std::overflow_error

5.3.2 std::underflow_error

5.3.3 std::system_error

5.3.4 std::ios_base::failure

5.4 其他重要异常类

5.4.1 std::bad_alloc

5.4.2 std::bad_cast

5.4.3 std::bad_typeid

5.4.4 std::bad_exception

5.4.5 std::bad_function_call

5.4.6 std::bad_optional_access

5.4.7 std::bad_variant_access

5.4.8 std::bad_any_cast

5.4.9 std::filesystem::filesystem_error

6. 异常的优缺点

6.1 异常的优点

6.2异常的缺点

5.1 根类：`std::exception`

5.2 逻辑错误类 (`std::logic_error`)

5.2.1 `std::invalid_argument`

5.2.2 `std::domain_error`

5.2.3 `std::length_error`

5.2.4 `std::out_of_range`

5.3 运行时错误类 (`std::runtime_error`)

5.3.1 `std::overflow_error`

5.3.2 `std::underflow_error`

5.3.3 `std::system_error`

5.3.4 `std::ios_base::failure`

5.4.1 `std::bad_alloc`

5.4.2 `std::bad_cast`

5.4.3 `std::bad_typeid`

5.4.4 `std::bad_exception`

5.4.5 `std::bad_function_call`

5.4.6 `std::bad_optional_access`

5.4.7 `std::bad_variant_access`

5.4.8 `std::bad_any_cast`

5.4.9 `std::filesystem::filesystem_error`