C++ 异常捕获

C++中，异常处理是一个重要的机制，用于处理运行时错误。下面是关于C++异常捕获的重点知识：

1. 异常的基本概念

• 异常：异常是指在程序执行期间发生的意外情况，例如除零、数组越界、内存分配失败等。
• 异常处理：使用 try、catch 和 throw 关键字来实现异常的捕获和处理。

2. 异常的抛出

• 使用 throw 关键字来抛出一个异常：
• throw std::runtime_error("发生错误");
   

3. 异常的捕获

• 使用 try 块来包含可能引发异常的代码，使用 catch 块来捕获异常：
• try {
      // 可能抛出异常的代码
  } catch (const std::exception& e) {
      // 处理异常
      std::cerr << "捕获异常: " << e.what() << std::endl;
  }
   

4. 多个 catch 块

• 可以为不同类型的异常提供多个 catch 块：
• try {
      throw std::out_of_range("越界错误");
  } catch (const std::out_of_range& e) {
      std::cerr << "捕获越界异常: " << e.what() << std::endl;
  } catch (const std::exception& e) {
      std::cerr << "捕获其他异常: " << e.what() << std::endl;
  }
   

5. 自定义异常

• 可以通过继承 std::exception 类来创建自定义异常：
• class MyException : public std::exception {
  public:
      const char* what() const noexcept override {
          return "自定义异常";
      }
  };
   

6. noexcept 关键字

• noexcept 用于标记函数，表示该函数不会抛出异常。对于性能优化和异常安全性很重要。
• void func() noexcept {
      // 不会抛出异常
  }

7. 异常安全性

• 异常安全性是指在发生异常时，程序的状态保持一致的能力。主要有三种保证：
  • 基本保证：如果发生异常，程序处于有效状态。
  • 强保证：如果发生异常，状态与调用前完全相同。
  • 无泄漏保证：即使发生异常，也不会泄漏资源。

8. 异常类型

在C++中，有几种常见的异常类型和场景，重点关注的异常主要包括：

1. 标准异常类型

• std::exception：所有异常的基类，所有自定义异常应继承此类。
• std::runtime_error：用于表示运行时错误，例如逻辑错误、状态错误等。
• std::logic_error：表示程序逻辑错误，例如非法参数、违反不变条件等。
• std::out_of_range：用于表示访问超出容器或数组边界的情况。
• std::invalid_argument：表示传递给函数的参数无效。

2. 内存相关异常

• std::bad_alloc：当内存分配失败时抛出。常见于动态内存分配（如使用 new 时）。
• std::bad_array_new_length：在尝试分配超出大小的数组时抛出。

3. 文件和输入输出异常

• std::ios_base::failure：用于表示输入输出操作中的错误，通常涉及文件流操作。

4. 自定义异常

• 开发者可以根据项目需求自定义异常类型，通常继承自 std::exception。常用于表示特定于应用程序的错误。

5. 其他常见异常

• std::overflow_error：表示算术运算溢出。
• std::underflow_error：表示算术运算下溢出。
• std::domain_error：表示传入函数的参数不在有效范围内。

异常处理的关注点

• 资源管理：在异常发生时，确保资源（如内存、文件句柄等）正确释放，以避免资源泄漏。
• 异常传播：理解异常的传播机制，确保在适当的层次捕获和处理异常。
• 异常安全性：确保函数在发生异常时保持有效状态，避免不一致性。

示例 1：抛出标准异常

#include <iostream>
#include <stdexcept>

void divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("除数不能为零");
    }
    std::cout << "结果: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 0);
    }
    catch (const std::invalid_argument &e) {
        std::cerr << "捕获异常: " << e.what() << std::endl;
    }
    return 0;
}

示例 2：自定义异常

#include <iostream>
#include <exception>

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "自定义异常发生";
    }
};

void test() {
    throw MyException();
}

int main() {
    try {
        test();
    } catch (const MyException& e) {
        std::cerr << "捕获自定义异常: " << e.what() << std::endl;
    }
    return 0;
}
 

示例 3：处理多个异常

#include <iostream>
#include <stdexcept>

void process(int value) {
    if (value < 0) {
        throw std::out_of_range("值不能小于零");
    }
    else if (value > 100) {
        throw std::overflow_error("值不能大于100");
    }
    std::cout << "处理值: " << value << std::endl;
}

int main() {
    try {
        process(-5);
    }
    catch (const std::out_of_range &e) {
        std::cerr << "捕获越界异常: " << e.what() << std::endl;
    }
    catch (const std::overflow_error &e) {
        std::cerr << "捕获溢出异常: " << e.what() << std::endl;
    }
    catch (const std::exception &e) {
        std::cerr << "捕获其他异常: " << e.what() << std::endl;
    }
    return 0;
}

示例 4：重新抛出异常

#include <iostream>
#include <stdexcept>

void riskyFunction() {
    throw std::runtime_error("发生运行时错误");
}

void handle() {
    try {
        riskyFunction();
    }
    catch (const std::runtime_error &e) {
        std::cerr << "处理异常: " << e.what() << std::endl;
        throw;  // 重新抛出异常
    }
}

int main() {
    try {
        handle();
    }
    catch (const std::runtime_error &e) {
        std::cerr << "捕获重新抛出的异常: " << e.what() << std::endl;
    }
    return 0;
}