c++异常处理机制通过try、catch和throw实现程序错误时的控制权转移。1. try块包裹可能抛出异常的代码，若发生异常则立即停止执行并寻找匹配的catch块；2. catch块用于捕获并处理特定类型的异常，可有多个以处理不同异常类型，catch(...)用于捕获所有未被处理的异常；3. throw用于显式抛出异常，通常建议抛出std::exception派生类的实例。异常沿调用栈传播，若未被捕获将导致程序终止。合理使用异常处理能提升代码可读性和健壮性，但需注意性能开销及避免过度使用。自定义异常类应继承自std::exception并重写what()方法。现代c++推荐使用noexcept代替异常规范来声明函数是否抛出异常。raii技术通过对象生命周期管理资源，确保异常安全。
C++异常处理的核心在于提供一种机制，使得程序在遇到无法正常处理的错误时，能够安全地转移控制权，避免程序崩溃。简单来说，就是“预防为主，治疗为辅”，try{}语句块尝试执行可能抛出异常的代码，catch{}语句块捕获并处理异常，而throw关键字则用于显式地抛出异常。
解决方案
C++的异常处理机制主要依赖于三个关键字：try、catch和throw。它们共同构成了一个完整的异常处理流程。
立即学习“C++免费学习笔记（深入）”；
try块：
try块用于包裹可能抛出异常的代码段。如果try块内的代码抛出了异常，程序会立即停止执行try块中剩余的代码，并尝试寻找匹配的catch块。
try {
// 可能抛出异常的代码
int result = divide(a, b);
std::cout << "Result: " << result << std::endl; // 如果divide抛出异常，这行代码不会执行
}
catch (...) {
// 处理异常
}catch块：
catch块用于捕获并处理特定类型的异常。可以有多个catch块，每个catch块处理不同类型的异常。catch块的参数指定了它所能捕获的异常类型。如果抛出的异常类型与catch块的参数类型匹配，该catch块就会被执行。
try {
// ...
}
catch (const std::runtime_error& error) {
std::cerr << "Runtime error: " << error.what() << std::endl;
}
catch (const std::exception& error) {
std::cerr << "Standard exception: " << error.what() << std::endl;
}
catch (...) {
std::cerr << "Unknown exception" << std::endl; // 捕获所有未被前面catch处理的异常
}注意，catch(...)可以捕获任何类型的异常，但通常应该放在所有其他catch块之后，作为最后的兜底方案。
throw关键字：
throw关键字用于显式地抛出一个异常。可以抛出任何类型的对象作为异常，但通常建议抛出继承自std::exception的类的实例，这样可以更好地利用标准库提供的异常处理机制。
double divide(double a, double b) {
if (b == 0) {
throw std::runtime_error("Division by zero!");
}
return a / b;
}抛出异常后，程序会沿着调用栈向上寻找匹配的catch块。如果在当前函数中没有找到匹配的catch块，异常会被传递到调用该函数的函数中，以此类推，直到找到匹配的catch块或者到达main函数。如果在main函数中仍然没有找到匹配的catch块，程序会调用std::terminate函数，导致程序异常终止。
一个完整的例子：
#include <iostream>
#include <stdexcept>
double divide(double a, double b) {
if (b == 0) {
throw std::runtime_error("Division by zero!");
}
return a / b;
}
int main() {
double x = 10.0;
double y = 0.0;
try {
double result = divide(x, y);
std::cout << "Result: " << result << std::endl;
}
catch (const std::runtime_error& error) {
std::cerr << "Caught an exception: " << error.what() << std::endl;
return 1; // 表示程序异常退出
}
catch (...) {
std::cerr << "Caught an unknown exception!" << std::endl;
return 2; // 表示程序异常退出
}
std::cout << "Program continues after exception handling." << std::endl;
return 0;
}在这个例子中，divide函数在除数为零时抛出一个std::runtime_error异常。main函数中的try块包裹了divide函数的调用。当异常被抛出时，控制权转移到与std::runtime_error类型匹配的catch块，该catch块打印错误信息并退出程序。如果divide函数没有抛出异常，程序将继续执行try块之后的代码。
异常处理的性能开销有多大？
异常处理确实会带来一定的性能开销，但这并不意味着应该完全避免使用异常处理。开销主要体现在两个方面：
-
try-catch块本身的开销： 即使没有异常抛出，try-catch块也会引入少量的性能开销。现代编译器通常会对try-catch块进行优化，使其在没有异常发生时开销很小。 -
异常抛出和捕获的开销： 当异常被抛出时，程序需要沿着调用栈向上寻找匹配的
catch块，这个过程可能会比较耗时。此外，异常对象的构造和析构也会带来额外的开销。
然而，在很多情况下，异常处理带来的代码可读性和健壮性的提升远大于其带来的性能开销。应该根据具体的应用场景来权衡是否使用异常处理。例如，在性能敏感的代码中，可以考虑使用错误码等其他方式来处理错误；而在对性能要求不高的代码中，可以使用异常处理来简化代码逻辑。
此外，使用异常处理的一个重要原则是：只在真正需要处理异常的地方捕获异常。避免在每个函数中都使用try-catch块，而应该将异常传递到更高层次的调用者，让它们来决定如何处理异常。
如何自定义异常类？
自定义异常类可以更好地表达程序中出现的特定错误情况。自定义异常类通常应该继承自std::exception或其子类，并重写what()方法，以便提供更详细的错误信息。
#include <iostream>
#include <stdexcept>
#include <string>
class MyException : public std::runtime_error {
public:
MyException(const std::string& message) : std::runtime_error(message) {}
// 可以添加自定义的成员变量和方法
int getErrorCode() const { return errorCode; }
private:
int errorCode = 123; // 示例错误码
};
void doSomething() {
// ...
if (/* 某些错误条件 */) {
throw MyException("Something went wrong!");
}
// ...
}
int main() {
try {
doSomething();
}
catch (const MyException& ex) {
std::cerr << "MyException caught: " << ex.what() << std::endl;
std::cerr << "Error code: " << ex.getErrorCode() << std::endl;
}
catch (const std::exception& ex) {
std::cerr << "Standard exception caught: " << ex.what() << std::endl;
}
return 0;
}在这个例子中，MyException类继承自std::runtime_error，并添加了一个自定义的错误码成员变量。doSomething函数在遇到错误时抛出MyException异常。main函数中的catch块捕获MyException异常，并打印错误信息和错误码。
异常规范（Exception Specification）在现代C++中还有用吗？
在C++11之前，可以使用异常规范来声明一个函数可能抛出的异常类型。例如：
void foo() throw(std::runtime_error); // foo函数可能抛出std::runtime_error类型的异常 void bar() throw(); // bar函数保证不抛出任何异常
然而，异常规范在现代C++中已经被弃用。主要原因有以下几点：
-
运行时检查： 异常规范是在运行时进行检查的。如果函数抛出了不在异常规范中的异常，程序会调用
std::unexpected函数，默认情况下会导致程序终止。这种运行时检查的开销比较大，而且容易导致意外的程序终止。 - 缺乏灵活性： 异常规范限制了函数可以抛出的异常类型，这在某些情况下可能会导致代码难以维护。
- 与模板不兼容： 异常规范与模板的结合使用比较复杂。
C++11引入了noexcept关键字来替代异常规范。noexcept关键字用于声明一个函数是否会抛出异常。如果一个函数被声明为noexcept，则表示该函数保证不抛出任何异常。如果noexcept函数抛出了异常，程序会调用std::terminate函数，导致程序异常终止。
void baz() noexcept; // baz函数保证不抛出任何异常
noexcept关键字的主要优点是：
-
编译时检查： 编译器可以利用
noexcept关键字进行优化，例如，可以避免为noexcept函数生成异常处理代码。 -
更好的可读性：
noexcept关键字可以更清晰地表达函数的异常行为。
总的来说，在现代C++中，应该使用noexcept关键字来声明函数的异常行为，而不是使用异常规范。
资源获取即初始化（RAII）与异常安全
资源获取即初始化（RAII）是一种C++编程技术，用于确保在程序执行过程中，资源总是能够被正确地释放，即使在发生异常的情况下也是如此。RAII的核心思想是将资源的管理与对象的生命周期绑定在一起。当对象被创建时，资源被获取；当对象被销毁时，资源被释放。
RAII通常通过以下方式实现：
- 封装资源： 将需要管理的资源封装在一个类中。
- 构造函数获取资源： 在类的构造函数中获取资源。
- 析构函数释放资源： 在类的析构函数中释放资源。
由于C++保证在任何情况下，对象的析构函数都会被调用（除非程序直接崩溃），因此RAII可以确保资源总是能够被正确地释放，即使在发生异常的情况下也是如此。
一个简单的例子：
#include <iostream>
#include <fstream>
#include <stdexcept>
class FileWrapper {
public:
FileWrapper(const std::string& filename) : file_(fopen(filename.c_str(), "r")) {
if (!file_) {
throw std::runtime_error("Failed to open file: " + filename);
}
std::cout << "File opened successfully." << std::endl;
}
~FileWrapper() {
if (file_) {
fclose(file_);
std::cout << "File closed successfully." << std::endl;
}
}
// 其他操作文件的成员函数
private:
FILE* file_;
};
int main() {
try {
FileWrapper myFile("my_file.txt");
// ... 使用文件 ...
throw std::runtime_error("Something went wrong while using the file.");
}
catch (const std::exception& ex) {
std::cerr << "Exception caught: " << ex.what() << std::endl;
}
return 0;
}在这个例子中，FileWrapper类封装了文件指针。构造函数打开文件，析构函数关闭文件。即使在try块中抛出了异常，myFile对象的析构函数仍然会被调用，从而确保文件被正确地关闭。
RAII是编写异常安全代码的关键技术。通过使用RAII，可以避免资源泄漏，并确保程序的健壮性。
