C++ 中的异常处理机制以及异常处理的优缺点

C++ 异常处理机制

在 C++ 程序运行过程中，可能会遇到各种错误情况，如内存分配失败、文件打开失败、除数为零等。异常处理机制提供了一种结构化的方式来处理这些错误情况，使得程序能够从异常情况中恢复或者以一种更合理的方式终止。

异常处理主要涉及三个关键字：try、catch和throw。

1.try块

try块用于包围可能会抛出异常的代码。

例如：在这个例子中，try块中的代码尝试进行除法运算，当除数为零时，就会抛出一个异常。try块的作用是标识出这段代码是需要进行异常监测的。

try {
    // 可能抛出异常的代码
    int m = 10;
    int n = 0;
    int r = m / n;  // 除数为零,会抛出异常
} catch (...) {
    // 捕获任何类型的异常
    std::cout << "An exception occurred" << std::endl;
}

2.throw语句

当在try块中发生异常情况时，可以使用throw语句来抛出一个异常对象。异常对象可以是任何类型，如基本类型、类类型等。

例如：

try {
    // 假设这是一个函数调用，函数内部可能会抛出异常
    someFunction();
} catch (const std::runtime_error& e) {
    // 捕获runtime_error类型的异常
    std::cout << "Runtime error: " << e.what() << std::endl;
}

如果someFunction()内部检测到一个运行时错误，它可能会这样抛出异常：

void someFunction() {
    // 检查某个条件
    if (errorCondition) {
        throw std::runtime_error("An error occurred in someFunction.");
    }
    // 正常的函数代码
}

这里throw语句抛出了一个std::runtime_error类型的异常对象，这个对象包含了一个错误信息字符串，可以通过what()函数来获取。

3.catch块

catch块用于捕获try块中抛出的异常。一个try块后面可以跟多个catch块，每个catch块可以捕获不同类型的异常。

例如：

try {
    // 可能会抛出不同类型异常的代码
    int* ptr = new int[1000000000]; // 可能会抛出bad_alloc异常
    // 其他可能抛出异常的操作
} catch (const std::bad_alloc& e) {
    std::cout << "Memory allocation failed: " << e.what() << std::endl;
} catch (const std::runtime_error& e) {
    std::cout << "Runtime error: " << e.what() << std::endl;
} catch (...) {
    // 捕获所有其他类型的异常
    std::cout << "An unknown exception occurred." << std::endl;
}

上面的代码中，第一个catch块专门用于捕获std::bad_alloc类型的异常，这种异常通常在内存分配失败时抛出。第二个catch块用于捕获std::runtime_error类型的异常。最后一个catch块（catch(...)）是一个通用的捕获块，可以捕获任何其他类型的异常。

异常类型匹配的catch块

当抛出一个异常后，程序会按照catch块出现的顺序来查找匹配的catch块。异常类型的匹配规则是基于类型兼容，即抛出的异常类型与catch块中声明的异常类型相同或者是其派生类型时，该catch块就会被执行。

例如：

try {
    throw std::invalid_argument("参数无效");
} catch (const std::runtime_error& e) {
    // 这个catch块不会被执行，因为异常类型不匹配
} catch (const std::invalid_argument& e) {
    // 这个catch块会被执行，因为异常类型匹配
    std::cerr << e.what() << std::endl;
}

catch块的参数

catch块可以有一个参数，用于接收抛出的异常对象。这个参数的类型决定了它能捕获哪些异常。通过这个参数，可以访问异常对象中的信息，如异常消息等。例如，std::exception类有一个what()成员函数，用于返回异常相关的文本信息。

异常处理的流程

当try块中的代码抛出一个异常时，程序会立即停止执行try块中剩余的代码。然后，程序会按照catch块出现的顺序，依次检查每个catch块，看哪个catch块能够匹配抛出的异常类型。

如果找到了匹配的catch块，就会执行该catch块中的代码，处理完异常后，程序会继续执行catch块后面的正常代码。如果没有找到匹配的catch块，程序可能会调用std::terminate()函数来终止程序（在没有合适的异常处理机制的情况下）。

异常的传播如果在一个函数中抛出了异常，而这个函数本身没有try - catch机制来捕获这个异常，那么这个异常会沿着函数调用栈向上传播，直到找到一个能够处理这个异常的try - catch块。例如：

void function2() {
    throw std::runtime_error("Exception in function2.");
}
void function1() {
    function2();
}
int main() {
    try {
        function1();
    } catch (const std::runtime_error& e) {
        std::cout << "Caught in main: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，function2()抛出了一个异常，由于它本身没有try - catch块来捕获这个异常，所以异常会传播到function1()，function1()也没有捕获机制，所以异常会继续传播到main()函数。在main()函数中有一个try - catch块能够捕获std::runtime_error类型的异常，所以在main()中会处理这个异常。

自定义异常类

除了使用 C++ 标准库提供的异常类（如std::runtime_error、std::logic_error、std::bad_alloc等），还可以自定义异常类。

例如：

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "This is my custom exception.";
    }
};

这个自定义的异常类MyException继承自std::exception类，并重写了what()函数来提供自定义的错误信息。可以在try - catch机制中使用这个自定义的异常类：

try {
    // 假设某个条件触发了自定义异常的抛出
    if (someCondition) {
        throw MyException();
    }
} catch (const MyException& e) {
    std::cout << "Caught custom exception: " << e.what() << std::endl;
}

何时使用异常处理以及其优缺点

使用情况：

1.错误恢复困难的情况：当在一个函数中发生错误，而在该函数内部无法方便地处理这个错误并继续执行正常流程时，适合使用异常处理。例如，在一个复杂的文件读取操作中，如果文件不存在或者文件格式错误，很难在文件读取函数内部直接解决这些问题，此时可以抛出异常，让调用者来决定如何处理。

2.分层架构之间的错误传递：在分层架构的软件系统中，底层模块（如数据库访问层）遇到错误时，可能无法自己处理。通过抛出异常，可以将错误信息向上层（如业务逻辑层和用户界面层）传递，让更适合处理该错误的层次来进行处理。

优点:

1.分离错误处理和正常业务逻辑：使得代码的主逻辑更加清晰。在没有异常处理的情况下，可能需要在每个可能出错的地方都进行错误检查和处理，这会使代码变得复杂且难以阅读。例如，在一个函数链中，使用异常处理可以让正常的函数调用流程不受错误检查代码的干扰，而在异常发生时，统一到catch块中进行处理。

2.提供了一种标准化的错误传播机制：在大型项目或者多个模块合作的项目中，不同模块可以通过抛出和捕获特定类型的异常来进行有效的错误信息传递。例如，一个数学库可以定义自己的异常类型，当用户使用库中的函数出现数学错误（如除数为零）时，抛出异常，让调用者知道发生了什么错误。

缺点:

1.性能开销：异常处理机制会带来一定的性能开销。当抛出异常时，程序需要进行栈展开（unwinding）操作，即沿着调用栈向上查找匹配的catch块，这个过程会涉及到一些额外的计算和内存操作。在对性能要求极高的场景下，频繁使用异常处理可能会影响程序的性能。

2.增加代码复杂性：如果过度使用或者不当使用异常处理，可能会使代码变得更加复杂和难以理解。例如，如果在一个简单的循环中频繁抛出和捕获异常，会使代码的控制流变得混乱。而且，确保正确地匹配异常类型和catch块也需要一定的细心和经验。