【C++】C++异常处理精要：从传统C语言错误处理到现代C++异常机制

文章目录

• 前言：
• 1. C语言传统的处理错误的方式
• 2. 什么是异常处理机制？
• 3. C++ 异常处理语法
• • 3.1. 异常抛出（Throw）
  • 3.2. 异常捕获（Catch）
  • 3.3. 异常传递（Exception Propagation）
  • 3.4. 异常规范（Exception Specification）
  • 3.5. 异常安全 （Exception safe）
• 4. C++异常处理的最佳实践
• • 4.1. 只在必要的情况下使用异常
  • 4.2. 使用具体的异常类
  • 4.3. 在异常处理器中进行资源释放
  • 4.4. 避免在析构函数中抛出异常
• 5. 示例代码
• • 5.1. 处理文件操作中的异常
  • 5.2. 处理用户输入中的异常
  • 5.3. 处理动态内存分配中的异常
• 6. 异常的优缺点
• • 6.1. C++异常的优点：
  • 6.2. C++异常的缺点：
• 总结：

前言：

在软件开发中，错误处理是确保程序稳定性和健壮性的关键环节。C语言和C++语言在错误处理方面有着显著的不同。C语言通常采用返回错误码或终止程序的方式，而C++则引入了异常处理机制，提供了一种更为灵活和强大的错误处理方式。本文将深入探讨C语言的传统错误处理方式，C++的异常处理机制，以及如何高效地使用C++的异常处理来提高代码的可读性、可维护性和异常安全性。

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

传统错误的处理机制

1. 终止程序，如assert, 缺陷：用户难以接受。如果内存发生错误，除0错误时就会终止程序。
2. 返回错误码，缺陷：需要程序员自己去找对应的错误。如果系统很多的接口库都是通过把错误码放到 errno中，表示错误。

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

2. 什么是异常处理机制？

异常处理机制是一种编程范式，用于在程序运行时检测到错误和异常情况时采取相应的措施。通过使用异常处理，我们可以将异常情况与正常代码逻辑分离开来，提高代码的可读性和可维护性。
C++中的异常处理机制基于异常类（Exception Class）和异常处理器（Exception Handler）的概念。当程序执行过程中发生异常时，会抛出一个异常对象，然后根据异常处理器的设置，选择合适的处理方式。

3. C++ 异常处理语法

3.1. 异常抛出（Throw）

在C++中，我们可以使用throw语句来抛出一个异常。抛出的异常可以是任意类型的对象，通常是派生自std::exception类的异常类对象。

• 异常的抛出和匹配原则：

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

throw MyException("An error occurred.");

3.2. 异常捕获（Catch）

异常的捕获通过使用try-catch语句块来实现。try块用于包裹可能抛出异常的代码片段，而catch块用于捕获并处理异常。

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

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

try {
    // 可能抛出异常的代码
} 
catch (const MyException& ex) {
    // 处理 MyException 类型的异常
}
catch (const std::exception& ex) {
    // 处理其他类型的异常
}
catch (...) {
    // 处理所有未捕获的异常，任意类型的异常都可以匹配 
}

3.3. 异常传递（Exception Propagation）

当异常在函数内部没有被捕获时，它会被传递给调用该函数的地方，并继续向上层函数传递，直到找到匹配的catch块或程序终止。

3.4. 异常规范（Exception Specification）

C++还支持异常规范，用于指定哪些异常可以在函数中被抛出。异常规范可以在函数声明或定义时使用。

void myFunction() throw(MyException, std::runtime_error);

然而，自C++11起，异常规范已经不再是推荐的做法，因为它引入了额外的复杂性，并且在实践中很少被使用。

3.5. 异常安全 （Exception safe）

• 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
• 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
• C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock 和 unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题。

4. C++异常处理的最佳实践

4.1. 只在必要的情况下使用异常

异常处理是有开销的，因此在性能敏感的代码或经常执行的代码中，应避免过度使用异常。只有在无法预测的错误或异常情况下才使用异常处理。

4.2. 使用具体的异常类

为不同类型的异常定义具体的异常类，并根据需要捕获和处理这些异常。这样可以提高异常处理的粒度，使代码更具可读性和可维护性。

4.3. 在异常处理器中进行资源释放

如果在try块中打开了资源（如文件、内存等），则应在相应的catch块中进行资源释放，以确保资源的正确管理。

4.4. 避免在析构函数中抛出异常

在析构函数中抛出异常会导致程序终止，因此应尽量避免在析构函数中抛出异常。如果必须抛出异常，请在析构函数中进行适当的处理，以避免资源泄漏。

5. 示例代码

5.1. 处理文件操作中的异常

#include <fstream>
#include <iostream>

int main() {
    try {
        std::ifstream file("file.txt");
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file.");
        }
        // Do something with the file...
        file.close();
    }
    catch (const std::exception& ex) {
        std::cerr << "Exception: " << ex.what() << std::endl;
    }
    return 0;
}

5.2. 处理用户输入中的异常

#include <iostream>
#include <stdexcept>

int main() {
    try {
        int num;
        std::cout << "Enter a number between 1 and 100: ";
        std::cin >> num;
        if (num < 1 || num > 100) {
            throw std::out_of_range("Number out of range.");
        }
        // Do something with the number...
    }
    catch (const std::exception& ex) {
        std::cerr << "Exception: " << ex.what() << std::endl;
    }
    return 0;
}

5.3. 处理动态内存分配中的异常

#include <iostream>
#include <new> // For std::bad_alloc

int main() {
    try {
        int* ptr = new int[10000000000];
        // Do something with the allocated memory...
        delete[] ptr;
    }
    catch (const std::bad_alloc& ex) {
        std::cerr << "Exception: Failed to allocate memory." << std::endl;
    }
    return 0;
}

6. 异常的优缺点

6.1. C++异常的优点：

1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包
   含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。(异常可以直接连续调用多层，不用层层处理，更方便)

// 1.下面这段伪代码我们可以看到ConnnectSql中出错了，先返回给ServerStart，
//ServerStart再返回给main函数，main函数再针对问题处理具体的错误。
// 2.如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因
//为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
int ConnnectSql()
{
    // 用户名密码错误
    if (...)
        return 1;

    // 权限不足
    if (...)
        return 2;
}

int ServerStart() {
    if (int ret = ConnnectSql() < 0)
        return ret;
    int fd = socket()
        if（fd < 0）
        return errno;
}

int main()
{
    if (ServerStart() < 0)
        ...

        return 0;
}

6.2. C++异常的缺点：

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

总结：

本文详细讨论了C语言中的传统错误处理方法，包括使用assert断言和返回错误码，以及这些方法的不足之处。随后，文章介绍了C++的异常处理机制，包括异常抛出、捕获、传递和异常规范的概念，并解释了异常处理的匹配原则和栈展开过程。此外，文章还强调了C++异常处理的最佳实践，如只在必要时使用异常、使用具体的异常类、在异常处理器中进行资源释放，以及避免在析构函数中抛出异常。通过示例代码，展示了如何在文件操作、用户输入和动态内存分配中应用异常处理技术。最后，文章分析了C++异常处理的优缺点，指出了异常处理在提供清晰错误信息、简化错误传播和处理方面的优势，同时也指出了其可能导致的执行流混乱、性能开销和资源管理问题。通过RAII等技术，可以有效解决资源泄漏和死锁等异常安全问题，提高代码的健壮性。总之，合理使用C++的异常处理机制，可以显著提升程序的质量和开发效率。