58、C++ 异常处理全解析

C++ 异常处理全解析

在 C++ 编程中，异常处理是一项至关重要的技术，它能够帮助我们更好地处理程序运行时出现的错误，提高程序的健壮性和可靠性。本文将深入探讨 C++ 中异常处理的各个方面，包括对象切片、异常重抛、捕获所有异常、函数异常处理等内容。

1. 对象切片与引用参数的重要性

在异常处理过程中，对象切片是一个常见的错误来源。当使用基类值参数来捕获派生类异常对象时，会发生对象切片现象，即派生类对象的派生部分被截断，只保留基类部分。例如：

End of the for loop (after the catch blocks) - i is 0
End of the for loop (after the catch blocks) - i is 1
End of the for loop (after the catch blocks) - i is 2
class Trouble object caught: There's a problem
End of the for loop (after the catch blocks) - i is 3
End of the for loop (after the catch blocks) - i is 4
class Trouble object caught: There's more trouble...
End of the for loop (after the catch blocks) - i is 5
class Trouble object caught: Really big trouble...
End of the for loop (after the catch blocks) - i is 6

上述输出表明，尽管捕获的是派生类对象，但由于使用了基类值参数，动态类型信息丢失，所有异常都被识别为基类类型。为避免对象切片，应始终在 catch 块中使用引用参数。

2. 异常重抛

当 catch 块捕获到异常后，可以使用 throw 关键字将异常重抛，让外层的 try 块处理。例如：

throw;  // 重抛当前异常

下面是一个异常重抛的示例代码：

// Ex15_06.cpp
// Rethrowing exceptions
#include <iostream>
#include "MyTroubles.h"

int main()
{
    Trouble trouble;
    MoreTrouble moreTrouble;
    BigTrouble bigTrouble;

    for (int i {}; i < 7; ++i)
    {
        try
        {
            try
            {
                if (i == 3)
                    throw trouble;
                else if (i == 5)
                    throw moreTrouble;
                else if(i == 6)
                    throw bigTrouble;
            }
            catch (const Trouble& t)
            {
                if (typeid(t) == typeid(Trouble))
                    std::cout << "Trouble object caught in inner block: " << t.what() << std::endl;
                else
                    throw;  // 重抛当前异常
            }
        }
        catch (const Trouble& t)
        {
            std::cout << typeid(t).name() << " object caught in outer block: "
                      << t.what() << std::endl;
        }
        std::cout << "End of the for loop (after the catch blocks) - i is " << i << std::endl;
    }
}

该示例的输出如下：

End of the for loop (after the catch blocks) - i is 0
End of the for loop (after the catch blocks) - i is 1
End of the for loop (after the catch blocks) - i is 2
Trouble object caught in inner block: There's a problem
End of the for loop (after the catch blocks) - i is 3
End of the for loop (after the catch blocks) - i is 4
class MoreTrouble object caught in outer block: There's more trouble...
End of the for loop (after the catch blocks) - i is 5
class BigTrouble object caught in outer block: Really big trouble...
End of the for loop (after the catch blocks) - i is 6

需要注意的是， throw t; 与 throw; 有本质区别。 throw t; 会复制异常对象，可能导致对象切片问题，而 throw; 则直接重抛现有异常对象，不会进行复制。

3. 捕获所有异常

可以使用省略号 (...) 作为 catch 块的参数，来捕获任何类型的异常。例如：

try
{
    // 可能抛出异常的代码...
}
catch(...)
{
    // 处理任何异常的代码...
}

下面是一个捕获所有异常的示例代码：

// Ex15_07.cpp
// Catching any exception
#include <iostream>
#include "MyTroubles.h"

int main()
{
    Trouble trouble;
    MoreTrouble moreTrouble;
    BigTrouble bigTrouble;

    for (int i {}; i < 7; ++i)
    {
        try
        {
            try
            {
                if (i == 3)
                    throw trouble;
                else if (i == 5)
                    throw moreTrouble;
                else if(i == 6)
                    throw bigTrouble;
            }
            catch (...)  // 捕获任何异常
            {
                std::cout << "We caught something! Let's rethrow it. " << std::endl;
                throw;  // 重抛当前异常
            }
        }
        catch (const Trouble& t)
        {
            std::cout << typeid(t).name() << " object caught in outer block: "
                      << t.what() << std::endl;
        }
        std::cout << "End of the for loop (after the catch blocks) - i is " << i << std::endl;
    }
}

该示例的输出如下：

End of the for loop (after the catch blocks) - i is 0
End of the for loop (after the catch blocks) - i is 1
End of the for loop (after the catch blocks) - i is 2
We caught something! Let's rethrow it.
class Trouble object caught in outer block: There's a problem
End of the for loop (after the catch blocks) - i is 3
End of the for loop (after the catch blocks) - i is 4
We caught something! Let's rethrow it.
class MoreTrouble object caught in outer block: There's more trouble...
End of the for loop (after the catch blocks) - i is 5
We caught something! Let's rethrow it.
class BigTrouble object caught in outer block: Really big trouble...
End of the for loop (after the catch blocks) - i is 6

捕获所有异常的 catch 块必须放在所有 catch 块的最后，以确保其他特定类型的异常能够被正确捕获。

4. 函数异常处理

4.1 抛出异常的函数

任何函数，包括构造函数，都可以抛出异常。要在调用函数中捕获异常，异常必须在函数内部抛出或重抛，且未被捕获。为避免程序因未捕获的异常而终止，调用抛出异常的函数时，必须将其放在 try 块中，并使用相应的 catch 块捕获异常。

4.2 函数 try 块

可以使用函数 try 块将整个函数体作为一个 try 块，并在函数体结束后添加相应的 catch 块。示例如下：

void doThat(int argument)
try
{
    // 函数代码...
}
catch(BigTrouble& ex)
{
    // 处理 BigTrouble 异常的代码...
}
catch(MoreTrouble& ex)
{
    // 处理 MoreTrouble 异常的代码...
}
catch(Trouble& ex)
{
    // 处理 Trouble 异常的代码...
}

需要注意的是，如果函数返回类型不是 void ，在 catch 块中必须执行适当的返回语句，否则行为未定义。

4.3 不抛出异常的函数

可以使用 noexcept 关键字指定函数不抛出异常。这意味着如果函数内部抛出异常，必须在函数内部捕获并处理，而不会重抛。例如：

void doThat(int argument) noexcept
try
{
    // 函数代码...
}
catch( ... )
{
    // 处理所有异常，不重抛...
}

如果使用 noexcept 指定的函数抛出未捕获的异常，程序将立即调用 std::terminate() 终止。

5. 构造函数 try 块

类构造函数也可以抛出异常。如果在构造函数中捕获到异常，通常需要重抛异常，以告知调用者对象未成功构造。可以使用构造函数 try 块将构造函数体（包括初始化列表）作为一个 try 块。示例如下：

Example::Example(int count) try : BaseClass(count)
{
    // 可能抛出异常的代码...
}
catch(...)  // 捕获任何异常
{
    // 处理异常的代码...
    throw;
}

在构造函数 try 块中，无论是否显式重抛异常，当 catch 块执行结束时，异常都会被重抛。

6. 异常与析构函数

当异常抛出时，处于作用域内的自动对象会被销毁，因此析构函数可能在处理异常的 catch 块执行之前被调用。可以使用 std::uncaught_exception() 函数检测析构函数是否因异常抛出而被调用。一般来说，析构函数不应抛出异常，因为析构函数默认是 noexcept 的，抛出异常会导致程序立即终止。

7. 标准库异常

C++ 标准库定义了多种异常类型，它们都派生自 std::exception 类。这些异常类型分为两大类： logic_error 和 runtime_error 。 logic_error 类异常通常是由程序逻辑缺陷引起的，理论上在程序执行前可以检测到；而 runtime_error 类异常通常与数据相关，只能在运行时检测到。常见的标准库异常类型包括：
- bad_cast ：由 dynamic_cast<>() 运算符抛出。
- bad_alloc ：由 new 运算符抛出。
- bad_typeid ：在使用 typeid() 运算符处理空指针时抛出。
- bad_weak_ptr ：在使用已过期的 weak_ptr 创建 shared_ptr 对象时抛出。
- out_of_range ：在使用 at() 成员函数访问字符串对象的字符时，索引超出合法范围时抛出。
- ios_base::failure ：由支持流输入输出的标准库函数抛出。

通过合理使用异常处理机制，我们可以更好地应对程序运行时的各种错误，提高程序的稳定性和可维护性。在实际编程中，应根据具体情况选择合适的异常处理方式，确保程序的健壮性。

异常处理流程图

graph TD;
    A[开始] --> B[函数调用或代码执行];
    B --> C{是否抛出异常};
    C -- 是 --> D[查找匹配的 catch 块];
    D --> E{是否找到匹配的 catch 块};
    E -- 是 --> F[执行 catch 块代码];
    F --> G{是否重抛异常};
    G -- 是 --> H[继续查找外层 try 块的 catch 块];
    H --> E;
    G -- 否 --> I[异常处理结束];
    E -- 否 --> J[程序终止];
    C -- 否 --> K[正常执行结束];

异常类型分类表

异常类型	基类	说明	示例情况
逻辑错误类	logic_error	因程序逻辑缺陷导致，理论上可在执行前检测	如索引越界、空指针解引用等
运行时错误类	runtime_error	与数据相关，只能在运行时检测	如内存分配失败、文件打开失败等

8. 异常处理的最佳实践

8.1 异常类型设计

在设计自定义异常类型时，应遵循一定的原则。首先，异常类型应继承自标准库的 std::exception 类或其派生类，这样可以利用标准库提供的统一接口，如 what() 函数，方便获取异常信息。其次，异常类型应具有明确的语义，能够清晰地表达异常发生的原因。例如：

#include <stdexcept>

class MyCustomException : public std::runtime_error {
public:
    MyCustomException(const std::string& message) : std::runtime_error(message) {}
};

在上述代码中， MyCustomException 继承自 std::runtime_error ，并通过构造函数传递异常信息。

8.2 异常处理层次

在处理异常时，应建立合理的异常处理层次。一般来说，底层函数应抛出具体的异常类型，而高层函数则负责捕获和处理这些异常。这样可以使异常处理更加清晰和模块化。例如：

// 底层函数
void lowLevelFunction() {
    // 可能抛出异常的代码
    if (/* 某种错误条件 */) {
        throw MyCustomException("Low level error occurred");
    }
}

// 高层函数
void highLevelFunction() {
    try {
        lowLevelFunction();
    } catch (const MyCustomException& ex) {
        // 处理异常
        std::cerr << "Caught exception: " << ex.what() << std::endl;
    }
}

8.3 资源管理

在异常处理过程中，资源管理是一个重要的问题。为了避免资源泄漏，应使用 RAII（资源获取即初始化）技术。例如，使用智能指针管理动态分配的内存：

#include <memory>

void resourceManagementExample() {
    std::unique_ptr<int> ptr(new int(42));
    // 可能抛出异常的代码
    if (/* 某种错误条件 */) {
        throw MyCustomException("Resource management error");
    }
    // 无需手动释放内存，智能指针会自动处理
}

9. 异常处理的性能考虑

异常处理虽然提供了强大的错误处理机制，但也会带来一定的性能开销。在性能敏感的代码中，应谨慎使用异常处理。以下是一些性能优化的建议：
- 减少异常抛出频率 ：尽量在代码中避免频繁抛出异常，可以通过条件判断等方式提前处理可能出现的错误。
- 避免不必要的异常捕获 ：在 catch 块中，只捕获真正需要处理的异常类型，避免使用捕获所有异常的 catch(...) 块。
- 异常处理代码优化 ：在 catch 块中，尽量减少复杂的操作，避免在异常处理过程中引入新的异常。

10. 异常处理的常见误区

10.1 捕获所有异常而不处理

在使用 catch(...) 捕获所有异常时，应确保在 catch 块中进行适当的处理，而不是简单地忽略异常。否则，可能会导致程序隐藏潜在的错误，难以调试。例如：

try {
    // 可能抛出异常的代码
} catch (...) {
    // 不做任何处理，这是错误的做法
}

10.2 异常处理与资源管理分离

在异常处理过程中，应确保资源的正确释放。如果在 catch 块中没有正确处理资源，可能会导致资源泄漏。例如：

void incorrectResourceManagement() {
    int* ptr = new int(42);
    try {
        // 可能抛出异常的代码
        if (/* 某种错误条件 */) {
            throw MyCustomException("Resource management error");
        }
    } catch (...) {
        // 没有释放 ptr 指向的内存，导致资源泄漏
    }
    delete ptr;
}

10.3 异常处理嵌套过深

异常处理嵌套过深会使代码变得复杂，难以理解和维护。应尽量避免过度嵌套异常处理代码，可以通过重构代码来简化异常处理逻辑。

异常处理操作步骤总结

操作类型	操作步骤
异常重抛	1. 在 catch 块中使用 throw; 关键字重抛当前异常。 2. 确保重抛的异常能被外层 try 块的 catch 块捕获。
捕获所有异常	1. 使用 catch(...) 作为 catch 块的参数。 2. 将捕获所有异常的 catch 块放在所有 catch 块的最后。
函数 try 块	1. 在函数定义时，将 try 关键字放在函数体的左花括号之前。 2. 在函数体的右花括号之后添加相应的 catch 块。
不抛出异常的函数	1. 在函数声明中使用 noexcept 关键字。 2. 在函数内部捕获并处理所有可能抛出的异常，不进行重抛。
构造函数 try 块	1. 在构造函数的参数列表右括号之后立即使用 try 关键字。 2. 在构造函数体的右花括号之后添加 catch 块。 3. 无论是否显式重抛，异常都会在 catch 块执行结束时重抛。

异常处理总结流程图

graph LR;
    A[异常处理最佳实践] --> B[异常类型设计];
    A --> C[异常处理层次];
    A --> D[资源管理];
    E[性能考虑] --> F[减少异常抛出频率];
    E --> G[避免不必要的异常捕获];
    E --> H[异常处理代码优化];
    I[常见误区] --> J[捕获所有异常而不处理];
    I --> K[异常处理与资源管理分离];
    I --> L[异常处理嵌套过深];
    M[操作步骤总结] --> N[异常重抛];
    M --> O[捕获所有异常];
    M --> P[函数 try 块];
    M --> Q[不抛出异常的函数];
    M --> R[构造函数 try 块];

通过对 C++ 异常处理的全面了解，我们可以更好地应对程序运行时的各种错误，提高程序的健壮性和可维护性。在实际编程中，应根据具体情况合理使用异常处理机制，避免常见的误区，同时注意性能优化。