C++异常处理

C++异常处理

try和catch

在C++中，try 是异常处理的关键字，用于定义一个代码块，该代码块中可能抛出异常。如果在 try 块中发生了异常，程序会立即停止当前块的执行，并查找与之匹配的 catch 块来处理异常。

下面是一个基本的 try-catch 结构的示例：

#include <iostream>
#include <stdexcept>

int main() {
    try {
        ... // 在这里尝试执行可能抛出异常的代码
        throw std::runtime_error("An error occurred.");
    } 
    catch (const std::exception& e) {
        // 如果mightThrowException函数抛出了异常，控制流会跳转到这里
        std::cerr << "Caught an exception: " << e.what() << '\n';
    }

    return 0;
}

如果发生异常，程序会跳转到匹配的 catch 块中执行相应的处理代码。在 catch 块中，通过 e.what() 获取异常的具体信息并打印出来。如果 try 块中没有抛出异常，则 catch 块不会被执行。

可能抛出异常的代码

1. 标准库容器操作：

   std::vector<int> vec;
   try {
       vec.at(10); // 如果索引超出范围，将会抛出std::out_of_range异常
   } catch (const std::out_of_range& e) {
       std::cerr << "Caught std::out_of_range: " << e.what() << '\n';
   }
   

2. 动态内存分配：

   try {
       int* ptr = new int[100000000]; // 如果内存不足，new表达式会抛出std::bad_alloc异常
   } catch (const std::bad_alloc& e) {
       std::cerr << "Caught std::bad_alloc: " << e.what() << '\n';
   }
   

3. 文件操作：

   std::ifstream file("non_existent_file.txt");
   if (!file) {
       try {
           file.exceptions(std::ios_base::failbit | std::ios_base::badbit); // 开启异常模式
           file.open("non_existent_file.txt"); // 此时，文件打开失败会抛出std::ios_base::failure异常
       } catch (const std::ios_base::failure& e) {
           std::cerr << "Caught std::ios_base::failure: " << e.what() << '\n';
       }
   }
   

std::exception

std::exception是C++标准库中的一个基类，所有的标准异常类都继承自它。这个类提供了异常处理的基本接口，通常用于创建自定义异常类或捕获和处理标准库引发的异常。

std::exception类定义了以下几个关键成员：

1. 构造函数：

   exception() noexcept;
   exception(const exception&) noexcept;
   exception& operator=(const exception&) noexcept;
   

   默认构造函数、复制构造函数和赋值运算符都是noexcept的，这意味着它们不会抛出异常，这对于在异常处理代码中使用异常类很重要。

2. 虚函数：

   virtual const char* what() const noexcept;
   

   这是一个虚函数，用于获取有关异常的描述信息。通常，派生类会重写这个函数，返回一个指向描述错误消息的C风格字符串的指针。

在实践中，你通常不会直接实例化std::exception对象，而是使用标准库中预定义的派生类，如std::runtime_error、std::logic_error等，或者创建自己的派生类来表示特定的错误类型。

异常类型

在C++中，异常的类型主要有以下几种：

1. 标准库预定义的异常类：

   • std::exception：这是所有标准库异常的基类，提供了基本的异常处理接口，如what()方法用于获取异常的描述信息。

   • 直接派生自std::exception的常见标准库异常类：

     • std::bad_alloc：在动态内存分配失败时抛出。
     • std::logic_error：表示违反了程序的逻辑约束条件，例如std::invalid_argument、std::domain_error、std::length_error、std::out_of_range等都派生自std::logic_error。
     • std::runtime_error：表示运行时条件违例，例如std::range_error、std::overflow_error、std::underflow_error等都派生自std::runtime_error。

2. 用户自定义异常：

   • 开发者可以根据需要创建自己的异常类，只需让它从std::exception或其他标准异常类派生即可。这样就可以定义自己的错误类型，并在适当的时候抛出。

例如：

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

try {
    // 一些可能抛出异常的代码
    if (conditionIsInvalid) {
        throw CustomException("Invalid condition encountered!");
    }
} catch (const CustomException& e) {
    std::cerr << "Caught custom exception: " << e.what() << '\n';
} catch (const std::exception& e) {
    std::cerr << "Caught standard exception: " << e.what() << '\n';
}

除了上述类型外，C++标准库并未限制异常类型的种类，任何类型（包括内置类型、用户自定义类型或标准库类型）都可以作为异常抛出，只要它们满足可以被复制的要求即可。不过实践中通常推荐抛出派生于std::exception的类型，以便于统一处理和提供有意义的错误信息。

自定义异常

在C++中，你可以自定义异常类，通过继承标准库中的 std::exception 类或者其派生类来实现。自定义异常通常用于表示特定的错误或异常情况，这样可以更加精确地捕获和处理问题。下面是一个自定义异常类的基本示例：

#include <iostream>
#include <exception>

// 自定义异常类
class MyCustomException : public std::exception {
public:
    // 构造函数，接收一个错误消息作为参数
    explicit MyCustomException(const char* message) : msg(message) {}

    // 重写虚函数，返回异常信息
    const char* what() const noexcept override {
        return msg.c_str();
    }

private:
    std::string msg; // 存储异常消息
};

void functionThatMightThrow() {
    if (...) {
        throw MyCustomException("A custom error has occurred!");
    }
}

int main() {
    try {
        functionThatMightThrow();
    } 
    catch (const MyCustomException& e) {
        std::cerr << "Caught a custom exception: " << e.what() << '\n';
    }

    return 0;
}

在这个例子中，我们创建了一个名为 MyCustomException 的自定义异常类，它继承自 std::exception，并覆盖了 what() 函数以返回自定义的错误消息。在 functionThatMightThrow() 函数中，当满足某种条件时，我们抛出自定义异常。在 main() 函数中，我们使用 try-catch 块捕获并处理这个自定义异常。