C++ 异常处理初探：如何利用 `try-catch` 捕获并处理运行时错误？

尊敬的各位编程爱好者、C++开发者们，大家好！

我是你们的编程向导，今天我们齐聚一堂，共同深入探讨C++中一个至关重要且强大无比的机制——异常处理。在软件开发的广阔天地里，错误和异常是不可避免的伙伴。它们可能是资源耗尽、无效输入、网络中断，甚至是逻辑错误。如何优雅、健壮地应对这些“意外”，是衡量一个程序质量高低的重要标准。C++的try-catch机制，正是为解决这一难题而生。

本次讲座，我们将从异常的基本概念出发，层层深入，剖析try-catch的语法、语义，探讨如何自定义异常、如何利用RAII（Resource Acquisition Is Initialization）确保资源安全，以及现代C++中noexcept的强大作用。我的目标是让大家不仅理解异常处理“是什么”，更能掌握“何时用”、“如何用”，以及“如何用好”异常处理，从而编写出更稳定、更易维护的C++代码。

---

1. 异常：程序世界里的“不速之客”

在深入try-catch之前，我们首先要明确一个概念：什么是异常？

在C++中，异常（Exception）是指在程序正常执行流程中发生的、打断程序正常执行路径的事件。它通常代表着一种“不寻常”或“错误”的情况，使得当前函数无法完成其预期的任务。

1.1 传统错误处理的局限性

在C++引入异常处理机制之前，我们通常依赖以下几种方式来处理错误：

1. 返回错误码（Return Codes）：函数返回一个特殊值（如-1、nullptr、false）来指示失败。

   • 优点：简单直接，开销小。
   • 缺点：
     • 侵入性强：调用者必须不断检查返回值，导致代码中充斥着大量的if语句，使正常逻辑与错误处理逻辑混杂在一起，降低可读性。
     • 易被忽略：如果调用者忘记检查返回值，错误就会被悄无声息地传播甚至掩盖。
     • 无法处理构造函数错误：构造函数没有返回值，无法直接通过返回码报告错误。
     • 错误信息有限：通常只能返回一个数字，难以携带详细的错误上下文。

   // 示例：使用错误码
   #include <iostream>
   #include <string>
   
   int divide_by_error_code(int numerator, int denominator, int& result) {
       if (denominator == 0) {
           return -1; // 错误码：除数为零
       }
       result = numerator / denominator;
       return 0; // 成功
   }
   
   int main() {
       int a = 10, b = 0, c;
       if (divide_by_error_code(a, b, c) == 0) {
           std::cout << "Result: " << c << std::endl;
       } else {
           std::cerr << "Error: Division by zero occurred." << std::endl;
       }
   
       int d = 10, e = 2, f;
       if (divide_by_error_code(d, e, f) == 0) {
           std::cout << "Result: " << f << std::endl;
       } else {
           std::cerr << "Error: Division by zero occurred." << std::endl;
       }
       return 0;
   }

2. 设置全局错误变量（Global Error Variables）：例如C语言中的errno。

   • 优点：函数只需设置变量，无需修改返回值。
   • 缺点：
     • 非线程安全：在多线程环境中容易出现竞争条件。
     • 状态污染：可能被其他不相关的代码意外修改。
     • 调用者责任：调用者仍需在每次调用后检查全局变量，同样容易被遗忘。

3. 断言（Assertions）：assert()宏，在调试模式下检查条件，失败则终止程序。

   • 优点：用于检测程序内部逻辑错误，开发阶段发现问题。
   • 缺点：
     • 仅限调试：发布版本通常会禁用断言，无法用于生产环境的错误处理。
     • 终止程序：不提供恢复机制，不适合处理可恢复的运行时错误。

这些传统方法在特定场景下仍有其价值，但它们在处理复杂、深层次嵌套调用或需要程序继续运行的错误时显得力不从心。异常处理正是为了弥补这些不足而设计的。

1.2 异常处理的优势

C++异常处理机制通过将错误检测与错误处理逻辑分离，带来了显著的优势：

• 清晰的代码结构：将正常的业务逻辑代码与错误处理代码分离，提高了代码的可读性和可维护性。
• 错误传播机制：异常可以跨越多个函数调用层级，直接传递到能够处理它的catch块，无需中间层函数层层传递错误码。
• 处理构造函数错误：构造函数无法返回错误码，但可以抛出异常来指示初始化失败。
• 携带丰富的错误信息：异常对象可以是任何类型，特别是自定义类，可以包含详细的错误描述、错误代码、发生位置等上下文信息。
• 强制处理：虽然不是强制捕获，但异常的“向上冒泡”机制使得未处理的异常会终止程序，从而促使开发者重视并处理潜在错误。

---

2. C++ 异常处理基础：try, throw, catch

C++异常处理的核心是三个关键字：try、throw和catch。

• try 块：用于标识一段可能抛出异常的代码。如果try块中的代码或其调用的任何函数抛出了异常，那么程序将立即跳转到相应的catch块进行处理。
• throw 语句：用于抛出一个异常。throw后面跟着一个表达式，该表达式的值（或其拷贝）就是被抛出的异常对象。
• catch 块：用于捕获并处理特定类型的异常。每个catch块都指定了它能捕获的异常类型。

2.1 基本语法示例

让我们看一个简单的除法运算示例，演示try-catch的基本用法：

#include <iostream>
#include <string>
#include <stdexcept> // 包含标准异常类

double divide(double numerator, double denominator) {
    if (denominator == 0) {
        // 当除数为零时，抛出一个异常
        // std::runtime_error 是标准库提供的一个异常类
        throw std::runtime_error("Error: Division by zero is not allowed.");
    }
    return numerator / denominator;
}

int main() {
    double num1 = 10.0;
    double num2 = 2.0;
    double num3 = 0.0;

    // 尝试执行可能抛出异常的代码
    try {
        std::cout << "Attempting division 10.0 / 2.0..." << std::endl;
        double result1 = divide(num1, num2);
        std::cout << "Result 1: " << result1 << std::endl;

        std::cout << "nAttempting division 10.0 / 0.0..." << std::endl;
        double result2 = divide(num1, num3); // 这一行会抛出异常
        std::cout << "Result 2: " << result2 << std::endl; // 这行代码将不会执行
    }
    // 捕获 std::runtime_error 类型的异常
    catch (const std::runtime_error& e) {
        // e 是捕获到的异常对象，通过 e.what() 获取错误信息
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }
    // 捕获所有其他类型的异常（泛型捕获）
    catch (...) {
        std::cerr << "Caught an unknown exception!" << std::endl;
    }

    std::cout << "nProgram continues after exception handling." << std::endl;
    return 0;
}

代码解析：

1. divide函数检查除数。如果为零，它不返回错误码，而是使用throw语句抛出一个std::runtime_error对象。这个对象在构造时带有一个错误消息字符串。
2. 在main函数中，try块包围了对divide函数的两次调用。
3. 第一次调用divide(num1, num2)成功执行，结果被打印。
4. 第二次调用divide(num1, num3)时，divide函数内部抛出了std::runtime_error异常。
5. 一旦异常被抛出，程序的控制流立即从throw点跳出，寻找匹配的catch块。try块中throw点之后的所有代码（例如std::cout << "Result 2: " << result2 << std::endl;）都将被跳过。
6. main函数中的第一个catch (const std::runtime_error& e)块能够捕获这个特定类型的异常。
7. 异常被捕获后，catch块中的代码被执行，打印出错误消息。
8. catch块执行完毕后，程序继续执行try-catch结构之后的代码。

---

3. 异常的类型与抛出：构建信息丰富的异常

异常对象可以是任何类型，但通常我们推荐抛出自定义异常类，它们继承自std::exception，并提供更详细的错误信息。

3.1 抛出基本数据类型异常 (不推荐)

虽然C++允许抛出基本数据类型，如int、char*或std::string，但这通常不被推荐，因为它缺乏足够的信息和类型层次结构。

// 示例：抛出基本类型异常 (不推荐)
void process_int(int value) {
    if (value < 0) {
        throw -1; // 抛出整数
    }
    if (value > 100) {
        throw "Value out of range!"; // 抛出 C 风格字符串
    }
    std::cout << "Processing int: " << value << std::endl;
}

int main() {
    try {
        process_int(50);
        process_int(-10); // 抛出 -1
    }
    catch (int error_code) {
        std::cerr << "Caught int exception: " << error_code << std::endl;
    }
    catch (const char* msg) {
        std::cerr << "Caught string literal exception: " << msg << std::endl;
    }
    catch (...) {
        std::cerr << "Caught unknown exception!" << std::endl;
    }
    return 0;
}

问题：这种方式的缺点在于，整数-1可能代表多种不同的错误，字符串也只是简单的描述，难以进行细粒度的错误分类和处理。

3.2 抛出标准库异常

C++标准库提供了一系列预定义的异常类，它们都继承自std::exception，并且大多数位于<stdexcept>头文件中。这些异常类提供了what()方法，返回一个C风格的字符串，描述异常的原因。

常用标准异常类：

异常基类	描述	派生类示例
std::exception	所有标准库异常的基类。	–
std::logic_error	表示程序逻辑错误，应在程序执行前通过检查避免。	std::domain_error, std::invalid_argument, std::length_error, std::out_of_range
std::runtime_error	表示运行时错误，通常是外部因素或不可预见的情况。	std::overflow_error, std::range_error, std::underflow_error, std::system_error
std::bad_alloc	内存分配失败（new 操作符）。	–
std::bad_cast	dynamic_cast 失败。	–
std::bad_typeid	typeid 操作符用于空指针。	–

在前面的divide示例中，我们使用了std::runtime_error，这是一个很好的实践。

3.3 抛出自定义异常类 (推荐)

为了提供更丰富、更具语义的错误信息，并构建清晰的异常层次结构，我们通常会定义自己的异常类。自定义异常类应该：

1. 继承自 std::exception 或其派生类：这使得自定义异常能够与标准异常一起被捕获和处理，并保证提供what()方法。
2. 重写 what() 方法：返回一个描述异常的C风格字符串。
3. 构造函数接受错误信息：方便在抛出时传递具体错误上下文。

#include <iostream>
#include <string>
#include <stdexcept> // 包含 std::exception

// 1. 定义一个自定义异常的基类
class MyBaseException : public std::exception {
public:
    // 构造函数，接受错误消息
    explicit MyBaseException(const std::string& message) : msg_(message) {}

    // 重写 what() 方法，提供异常描述
    const char* what() const noexcept override {
        return msg_.c_str();
    }

protected:
    std::string msg_; // 存储错误消息
};

// 2. 定义一个更具体的自定义异常类，继承自 MyBaseException
class FileIOException : public MyBaseException {
public:
    explicit FileIOException(const std::string& filename, const std::string& message)
        : MyBaseException("File I/O Error: " + filename + " - " + message), filename_(filename) {}

    const std::string& get_filename() const {
        return filename_;
    }

private:
    std::string filename_;
};

// 3. 定义另一个具体异常类
class InvalidArgumentException : public MyBaseException {
public:
    explicit InvalidArgumentException(const std::string& arg_name, const std::string& message)
        : MyBaseException("Invalid Argument Error: " + arg_name + " - " + message), arg_name_(arg_name) {}

    const std::string& get_arg_name() const {
        return arg_name_;
    }

private:
    std::string arg_name_;
};

// 模拟一个文件操作函数
void open_file(const std::string& filename) {
    if (filename.empty()) {
        throw InvalidArgumentException("filename", "Filename cannot be empty.");
    }
    if (filename == "non_existent.txt") {
        throw FileIOException(filename, "File does not exist or permission denied.");
    }
    std::cout << "Successfully opened file: " << filename << std::endl;
}

int main() {
    try {
        open_file("data.txt");
        open_file(""); // 抛出 InvalidArgumentException
        open_file("non_existent.txt"); // 抛出 FileIOException
    }
    // 先捕获更具体的异常类型
    catch (const FileIOException& e) {
        std::cerr << "Caught File I/O Exception: " << e.what() << " (File: " << e.get_filename() << ")" << std::endl;
    }
    catch (const InvalidArgumentException& e) {
        std::cerr << "Caught Invalid Argument Exception: " << e.what() << " (Arg: " << e.get_arg_name() << ")" << std::endl;
    }
    // 再捕获基类异常，捕获所有其他自定义异常
    catch (const MyBaseException& e) {
        std::cerr << "Caught a generic MyBaseException: " << e.what() << std::endl;
    }
    // 最后捕获标准库异常
    catch (const std::exception& e) {
        std::cerr << "Caught a standard exception: " << e.what() << std::endl;
    }
    // 捕获所有未知异常
    catch (...) {
        std::cerr << "Caught an unknown exception!" << std::endl;
    }

    std::cout << "nProgram continues after exception handling." << std::endl;
    return 0;
}

这个示例展示了如何构建一个有层次的异常体系，并根据异常类型进行细粒度处理。

---

4. 捕获异常的艺术：精确与泛化

捕获异常并非简单地写一个catch块。理解catch块的工作原理，特别是多重catch块的顺序和捕获引用的重要性，是高效异常处理的关键。

4.1 多重 catch 块与匹配顺序

一个try块可以跟着一个或多个catch块。当异常被抛出时，C++运行时会按照catch块定义的顺序，从上到下查找第一个能够匹配异常类型的catch块。

重要规则：

• 从特化到泛化：更具体的异常类型（派生类）应该放在其基类之前。如果把基类放在前面，那么所有派生类异常都会被基类捕获，导致更具体的catch块永远无法执行。
• 类型匹配：catch块的参数类型可以是抛出异常对象的类型、该类型的引用、该类型的基类引用，甚至是...（捕获所有）。

// 延用上文的 MyBaseException, FileIOException, InvalidArgumentException

int main() {
    try {
        // ... 假设这里会抛出 FileIOException 或 InvalidArgumentException
        open_file("non_existent.txt"); // 抛出 FileIOException
    }
    // 正确顺序：先捕获派生类
    catch (const FileIOException& e) {
        std::cerr << "Specific handler for FileIOException: " << e.what() << std::endl;
    }
    catch (const InvalidArgumentException& e) {
        std::cerr << "Specific handler for InvalidArgumentException: " << e.what() << std::endl;
    }
    // 再捕获基类
    catch (const MyBaseException& e) {
        std::cerr << "Generic handler for MyBaseException: " << e.what() << std::endl;
    }
    // 最后捕获所有其他异常
    catch (const std::exception& e) {
        std::cerr << "Generic handler for std::exception: " << e.what() << std::endl;
    }
    catch (...) {
        std::cerr << "Ultimate fallback handler for any unknown exception." << std::endl;
    }
    return 0;
}

4.2 捕获引用 (const Type&)

捕获异常时，强烈推荐使用引用（const Type&）。

• 避免切片（Object Slicing）：如果按值捕获基类异常，派生类异常对象可能会被“切片”，丢失派生类特有的信息。使用引用可以保持对象的完整性。
• 避免拷贝开销：异常对象可能包含大量数据。按值捕获会创建异常对象的一个拷贝，这会增加性能开销，尤其是在异常频繁发生或异常对象很大的情况下。使用引用避免了拷贝。
• 多态性：通过捕获基类引用，可以捕获所有继承自该基类的派生类异常，实现多态处理。

// 示例：捕获引用避免切片
class BaseError : public std::exception {
public:
    BaseError(const std::string& msg) : message(msg) {}
    const char* what() const noexcept override { return message.c_str(); }
protected:
    std::string message;
};

class DerivedError : public BaseError {
public:
    DerivedError(const std::string& msg, int code) : BaseError(msg), error_code(code) {}
    int get_code() const { return error_code; }
private:
    int error_code;
};

void throw_derived() {
    throw DerivedError("Something specific went wrong!", 123);
}

int main() {
    try {
        throw_derived();
    }
    catch (const BaseError& e) { // 捕获引用
        std::cerr << "Caught by reference (BaseError): " << e.what() << std::endl;
        // 尝试向下转型以获取DerivedError的特有信息
        const DerivedError* derived = dynamic_cast<const DerivedError*>(&e);
        if (derived) {
            std::cerr << "  (Downcasted to DerivedError, code: " << derived->get_code() << ")" << std::endl;
        }
    }
    /*
    // 如果这样捕获，会发生切片，无法获取 error_code
    catch (BaseError e) { // 按值捕获
        std::cerr << "Caught by value (BaseError): " << e.what() << std::endl;
        // 这里的e已经是BaseError类型，DerivedError特有信息丢失
    }
    */
    return 0;
}

4.3 重新抛出异常 (throw;)

在catch块中，可以使用throw;语句（不带任何表达式）来重新抛出当前捕获到的异常。这在以下场景非常有用：

• 部分处理：当前函数可以对异常进行部分处理（例如记录日志、清理局部资源），但认为自己无法完全解决问题，需要将异常继续向上层调用者传播。
• 多层异常处理：一个catch块捕获了异常，处理后发现需要将它转换为另一种异常类型，或者只是简单地记录后继续传播。

// 示例：重新抛出异常
void function_level_1() {
    try {
        throw std::runtime_error("Error from function_level_1");
    }
    catch (const std::runtime_error& e) {
        std::cerr << "Level 1 caught: " << e.what() << ". Logging and rethrowing..." << std::endl;
        // 进行一些局部处理，如日志记录
        // ...
        throw; // 重新抛出相同的异常
    }
}

void function_level_2() {
    try {
        function_level_1();
    }
    catch (const std::exception& e) {
        std::cerr << "Level 2 caught: " << e.what() << ". This level handles it." << std::endl;
    }
}

int main() {
    function_level_2();
    std::cout << "nProgram finished." << std::endl;
    return 0;
}

---

5. 栈展开（Stack Unwinding）：异常传播的幕后英雄

当一个异常被抛出且没有在当前函数内部捕获时，C++运行时会启动一个被称为栈展开（Stack Unwinding）的过程。

栈展开的机制：

1. 程序沿着函数调用栈向后回溯，逐层离开当前函数。
2. 在离开每个函数时，该函数中所有已构造的局部对象（包括自动变量）的析构函数都会被调用。
3. 这个过程一直持续，直到找到一个能够捕获该异常的try-catch块。
4. 如果栈展开到达main函数外部，仍然没有找到匹配的catch块，程序将调用std::terminate()函数，默认行为是终止程序（通常通过调用abort()）。

栈展开的重要性：

栈展开机制是C++异常处理能够实现资源安全的基石，因为它保证了局部对象的生命周期管理。

#include <iostream>
#include <string>
#include <vector>

class Resource {
public:
    std::string name;
    Resource(const std::string& n) : name(n) {
        std::cout << "Resource " << name << " acquired." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource " << name << " released." << std::endl;
    }
};

void func_c() {
    Resource res_c("C");
    std::cout << "Inside func_c, about to throw." << std::endl;
    throw std::runtime_error("Error from func_c!");
    std::cout << "This line in func_c will not be reached." << std::endl;
}

void func_b() {
    Resource res_b("B");
    std::cout << "Inside func_b, calling func_c." << std::endl;
    func_c(); // func_c会抛出异常
    std::cout << "This line in func_b will not be reached." << std::endl;
}

void func_a() {
    Resource res_a("A");
    std::cout << "Inside func_a, calling func_b." << std::endl;
    func_b(); // func_b会传播func_c的异常
    std::cout << "This line in func_a will not be reached." << std::endl;
}

int main() {
    std::cout << "Starting program." << std::endl;
    Resource res_main("Main"); // main函数中的资源

    try {
        func_a();
    }
    catch (const std::runtime_error& e) {
        std::cerr << "Caught exception in main: " << e.what() << std::endl;
    }

    std::cout << "Program finished." << std::endl;
    return 0;
}

运行结果预期：

Starting program.
Resource Main acquired.
Resource A acquired.
Inside func_a, calling func_b.
Resource B acquired.
Inside func_b, calling func_c.
Resource C acquired.
Inside func_c, about to throw.
Resource C released. // func_c 的局部资源被释放
Resource B released. // func_b 的局部资源被释放
Resource A released. // func_a 的局部资源被释放
Caught exception in main: Error from func_c!
Resource Main released. // main 函数的局部资源被释放
Program finished.

可以看到，即使异常打断了正常的执行流，所有局部资源都能够被正确地析构和释放，这正是RAII的强大体现。

---

6. 资源管理与 RAII：异常安全的基石

RAII (Resource Acquisition Is Initialization) 是C++中一种强大的编程范式，它将资源的生命周期与对象的生命周期绑定在一起。

• 资源获取即初始化：当对象被创建时（构造函数），它获取或管理资源（例如，打开文件、分配内存、获取锁）。
• 资源释放即析构：当对象超出其作用域时（析构函数），它会自动释放或解除管理该资源。

RAII 如何与异常处理结合？

在异常发生时，栈展开机制会确保局部对象的析构函数被调用。因此，如果你的资源管理遵循RAII原则，那么无论代码是正常完成还是被异常中断，资源都将得到妥善处理，避免资源泄露。

6.1 智能指针：典型的 RAII 实践

C++标准库中的智能指针（std::unique_ptr、std::shared_ptr）是RAII的典型应用。它们管理动态分配的内存，确保在指针超出作用域时内存被自动释放。

#include <iostream>
#include <memory> // 智能指针头文件
#include <stdexcept>

void risky_function() {
    // 使用 std::unique_ptr 管理动态分配的内存
    std::unique_ptr<int> p_int(new int(10));
    std::cout << "Dynamic int allocated: " << *p_int << std::endl;

    // 假设这里发生了一些导致异常的错误
    if (*p_int == 10) {
        throw std::runtime_error("Simulated critical error in risky_function!");
    }

    // 这行代码将不会执行
    std::cout << "This line is after potential throw." << std::endl;
} // p_int 在这里超出作用域，其析构函数被调用，内存自动释放

int main() {
    try {
        risky_function();
    }
    catch (const std::runtime_error& e) {
        std::cerr << "Caught exception in main: " << e.what() << std::endl;
    }
    std::cout << "Program finished. Memory for p_int was safely released." << std::endl;
    return 0;
}

即使risky_function抛出异常，std::unique_ptr所管理的内存也会在p_int析构时被正确释放，避免了内存泄露。

6.2 自定义 RAII 类

你可以为任何需要管理其生命周期的资源创建自定义RAII类。例如，一个文件句柄包装器：

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>

// 自定义文件句柄RAII包装器
class FileHandle {
public:
    FileHandle(const std::string& filename, std::ios_base::openmode mode) {
        file_stream_.open(filename, mode);
        if (!file_stream_.is_open()) {
            throw FileIOException(filename, "Failed to open file.");
        }
        std::cout << "File '" << filename << "' opened successfully." << std::endl;
    }

    // 析构函数确保文件关闭
    ~FileHandle() {
        if (file_stream_.is_open()) {
            file_stream_.close();
            std::cout << "File closed." << std::endl;
        }
    }

    // 禁用拷贝和赋值，因为文件句柄通常不应该被拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    std::ofstream& get_stream() {
        return file_stream_;
    }

private:
    std::ofstream file_stream_;
};

void write_data_to_file(const std::string& filename, const std::string& data) {
    FileHandle fh(filename, std::ios::out | std::ios::trunc); // RAII 对象
    fh.get_stream() << data;
    std::cout << "Data written to file." << std::endl;
    // 模拟写入后发生错误
    if (data.length() > 20) {
        throw std::runtime_error("Data too long, simulated error after write.");
    }
} // fh 在这里超出作用域，文件会自动关闭

int main() {
    try {
        write_data_to_file("output.txt", "Hello, RAII world!");
        write_data_to_file("non_existent_dir/output.txt", "This will fail to open."); // 抛出 FileIOException
        write_data_to_file("output2.txt", "This is a very long string that will trigger an exception after writing the data."); // 抛出 runtime_error
    }
    catch (const FileIOException& e) {
        std::cerr << "Caught File I/O Exception: " << e.what() << std::endl;
    }
    catch (const std::runtime_error& e) {
        std::cerr << "Caught Runtime Error: " << e.what() << std::endl;
    }
    catch (...) {
        std::cerr << "Caught an unknown exception!" << std::endl;
    }

    std::cout << "nProgram continues, all files should be closed." << std::endl;
    return 0;
}

无论write_data_to_file函数是正常返回还是抛出异常，FileHandle对象的析构函数都会被调用，确保文件句柄被正确关闭。

---

7. 异常规范与 noexcept：承诺与优化

在C++11之前，C++引入了异常规范（Exception Specifications），例如void func() throw(std::bad_alloc);声明函数只可能抛出std::bad_alloc。然而，这些规范在实践中被证明是有缺陷的：它们在运行时检查，效率低下，且行为不直观（违反规范会抛出std::unexpected）。因此，C++11起异常规范被弃用，C++17已移除。

7.1 noexcept 关键字 (C++11 及以后)

C++11引入了noexcept关键字，它是一种更现代、更强大的异常规范机制。

• 编译期检查：noexcept是一个编译期修饰符，它向编译器承诺函数或表达式不会抛出任何异常。
• 性能优化：编译器可以利用noexcept信息进行优化，例如避免保存栈状态。
• 违反承诺的后果：如果一个声明为noexcept的函数在运行时抛出了异常，程序将立即调用std::terminate()终止执行，而不是进行栈展开。

noexcept 的两种形式：

1. noexcept：表示函数不抛出任何异常。

   void do_something_safe() noexcept {
       // 这段代码保证不抛出异常
   }

2. noexcept(expression)：一个条件性的noexcept，当expression求值为true时，函数不抛出异常。expression通常是noexcept运算符，用于检查某个操作是否是无异常的。

   template<typename T>
   void swap(T& a, T& b) noexcept(noexcept(a.swap(b))) {
       // 如果 T::swap 是 noexcept，那么这个 swap 也是 noexcept
       a.swap(b);
   }

noexcept 运算符：

noexcept(expression)也可以用作一个运算符，它在编译时评估expression是否会抛出异常，返回true或false。

#include <iostream>
#include <vector>

void might_throw() {
    throw std::runtime_error("oops");
}

void will_not_throw() noexcept {
    // ...
}

int main() {
    std::cout << "noexcept(might_throw()): " << std::boolalpha << noexcept(might_throw()) << std::endl; // false
    std::cout << "noexcept(will_not_throw()): " << std::boolalpha << noexcept(will_not_throw()) << std::endl; // true
    std::cout << "noexcept(std::vector<int>().push_back(1)): " << std::boolalpha << noexcept(std::vector<int>().push_back(1)) << std::endl; // true (C++11及以后)
    return 0;
}

7.2 noexcept 的重要应用：移动语义

在C++中，为移动构造函数和移动赋值运算符声明noexcept至关重要。

• 性能优化：标准库容器（如std::vector）在需要重新分配内存并移动元素时，会检查元素的移动构造函数和移动赋值运算符是否为noexcept。
  • 如果它们是noexcept，容器可以直接移动元素，效率更高。
  • 如果不是noexcept，容器会选择更安全的拷贝操作（如果可用），以保证强异常安全，但会牺牲性能。
• 保证强异常安全：对于容器，如果移动操作可能抛出异常，那么在移动过程中发生异常，容器可能处于无效状态。noexcept承诺移动操作不会抛出异常，从而简化了容器的实现，并允许它提供强异常安全保证。

#include <iostream>
#include <vector>
#include <string>
#include <utility> // for std::move

class MyMovableClass {
public:
    std::string data;

    // 构造函数
    MyMovableClass(const std::string& s) : data(s) {
        std::cout << "Constructed: " << data << std::endl;
    }

    // 拷贝构造函数
    MyMovableClass(const MyMovableClass& other) : data(other.data) {
        std::cout << "Copied: " << data << std::endl;
    }

    // 移动构造函数 (声明为 noexcept)
    MyMovableClass(MyMovableClass&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Moved: " << data << std::endl;
    }

    // 析构函数
    ~MyMovableClass() {
        std::cout << "Destructed: " << data << std::endl;
    }
};

int main() {
    std::vector<MyMovableClass> vec;
    vec.reserve(3); // 预留空间，避免第一次 push_back 导致重新分配

    std::cout << "--- Pushing back first element ---" << std::endl;
    vec.push_back(MyMovableClass("A")); // 调用构造函数，然后移动构造函数 (如果 reserve 不足)

    std::cout << "n--- Pushing back second element ---" << std::endl;
    vec.push_back(MyMovableClass("B"));

    std::cout << "n--- Forcing reallocation (if reserve was not enough or removed) ---" << std::endl;
    // 如果容量不足，push_back 会导致重新分配和移动现有元素
    // 如果 MyMovableClass 的移动构造函数没有 noexcept，std::vector 可能会选择拷贝构造
    vec.push_back(MyMovableClass("C"));

    std::cout << "n--- Vector elements ---" << std::endl;
    for (const auto& item : vec) {
        std::cout << item.data << " ";
    }
    std::cout << std::endl;

    std::cout << "n--- End of main ---" << std::endl;
    return 0;
}

如果没有noexcept，std::vector在扩容时可能会选择拷贝而不是移动，这会影响性能。

---

8. 异常安全保证：代码的健壮性承诺

异常安全是指程序在异常发生时，能够保持其状态的有效性，并且不会泄露资源。C++社区定义了三种主要的异常安全保证级别：

1. 无抛出保证 (No-Throw Guarantee)：

   • 级别：最高。
   • 含义：函数保证绝不抛出任何异常。如果它真的抛出了，程序会立即终止（通过std::terminate）。
   • 实现：使用noexcept关键字进行标记。
   • 示例：析构函数、交换操作（std::swap）、移动构造函数和移动赋值运算符通常应该提供此保证。

2. 强保证 (Strong Guarantee)：

   • 级别：次高。
   • 含义：函数要么完全成功，要么在失败（抛出异常）时，程序的状态保持不变，就像该函数从未被调用过一样（事务语义）。不会有副作用，所有资源都恢复到调用前的状态。
   • 实现：通常通过“拷贝并交换”或先在临时对象上操作，成功后再原子性地替换原对象来实现。
   • 示例：std::vector::push_back（当元素类型支持强保证时）。

3. 基本保证 (Basic Guarantee)：

   • 级别：最低实用级别。
   • 含义：函数在失败（抛出异常）时，程序的状态仍然是有效的，所有资源都不会泄露。但程序的状态可能已发生改变，并且处于一种未明确但有效的状态。
   • 实现：主要通过RAII来实现资源不泄露。
   • 示例：大多数无法提供强保证的函数至少应提供基本保证。

设计异常安全代码的策略：

• 优先提供无抛出保证：对于析构函数、移动操作和交换操作。
• 优先提供强保证：对于那些修改对象状态的操作，如果可行，尽量使用“拷贝并交换”等技术。
• 至少提供基本保证：确保所有资源都通过RAII管理，即使发生异常也不会泄露。

---

9. 何时使用异常，何时避免异常？

异常处理虽强大，但并非万能药。合理地使用异常是高效C++编程的关键。

9.1 适合使用异常的场景

• 真正“异常”的情况：表示函数无法完成其预定任务，通常是不可恢复的错误，或在正常执行路径中不应出现的情况。例如，文件不存在、内存分配失败、网络连接中断、无效的外部输入数据等。
• 构造函数失败：构造函数没有返回值，只能通过抛出异常来报告初始化失败。
• 资源分配失败：例如new操作符抛出std::bad_alloc。
• 跨越多个函数调用层级传递错误：当错误发生在一个深层嵌套的函数中，而只有顶层调用者才能处理时，异常是最佳选择。
• 分离正常逻辑与错误处理逻辑：使代码更清晰。

9.2 应该避免使用异常的场景

• 可预期的、频繁发生的“错误”：如果一个“错误”是业务逻辑的一部分，并且经常发生，那么使用返回值或std::optional（C++17）可能更合适。例如，用户输入格式错误，尝试从空队列中弹出元素等。将这些情况视为异常会增加性能开销，并使代码流难以跟踪。
• 性能敏感的代码路径：异常的抛出和捕获过程涉及栈展开，具有一定的运行时开销，这对于性能极其敏感的代码可能无法接受。
• 低层级库或接口：对于底层库，通常建议提供多种错误报告机制（例如，既支持错误码也支持异常），或者只使用错误码，以适应不同的上层应用需求。
• 析构函数中抛出异常：这是C++中的一个严重禁忌！ 如果析构函数抛出异常，并且此时程序正处于栈展开过程中（另一个异常正在传播），那么会导致std::terminate()被调用，程序立即终止。析构函数必须是noexcept的，或至少保证不抛出异常。

异常与错误码的比较：

特性	异常处理	错误码
语义	表示程序执行流中的“不寻常”事件	表示函数操作的结果（成功/失败）
控制流	非局部跳转，跨函数调用栈	局部跳转，通过返回值检查
强制性	未捕获会导致程序终止	易被忽略，需手动检查
错误信息	丰富，可携带复杂对象	通常为数字，信息量有限
代码结构	正常逻辑与错误处理分离，更清晰	正常逻辑与错误处理混杂，if地狱
性能	抛出和捕获有开销，但正常路径无开销	每次调用都有少量开销，无额外错误开销
适用场景	构造函数失败、资源分配失败、深层错误	预期错误、频繁错误、低层库
RAII	完美结合，确保资源安全	需手动清理，易发生资源泄露

---

10. 最佳实践

遵循以下最佳实践，可以帮助你更有效地使用C++异常处理：

1. 只抛出有意义的异常：异常应该表示程序真正遇到了无法继续执行的“异常”情况。
2. 异常对象应包含足够的信息：自定义异常类继承自std::exception，并提供详细的错误消息、错误码、发生位置等上下文信息。
3. 避免在析构函数中抛出异常：析构函数应该提供noexcept保证。
4. 使用 RAII 管理所有资源：这包括内存、文件句柄、网络连接、锁等，确保无论是否发生异常，资源都能被正确释放。
5. 避免catch (...)除非你清楚其目的：泛型捕获会掩盖异常类型，导致无法进行细粒度处理。它通常只用于最顶层的错误日志记录或程序终止前的清理。
6. 尽可能捕获引用（const Type&）：避免对象切片和不必要的拷贝。
7. 构建清晰的异常体系结构：让你的自定义异常类继承自std::exception或其派生类，形成逻辑上的层次结构。
8. 将异常捕获点放在合适的粒度：不要在每个函数中都捕获异常，而是在能够真正处理或恢复错误的层级进行捕获。
9. 记录异常信息：在捕获异常时，记录详细的日志，包括异常类型、错误消息、发生时间、调用栈等，这对于调试和问题排查至关重要。
10. 保持异常安全：努力为你的代码提供强或基本异常安全保证。

---

C++的异常处理机制，如同双刃剑，用之得当，能使程序健壮且清晰；反之，则可能引入新的复杂性。通过深入理解try-catch的运作机制、异常的类型、RAII原则以及noexcept的语义，我们得以构建出更加可靠、更具弹性的C++应用程序。在现代C++编程中，异常处理已是不可或缺的工具，掌握它，无疑将提升你作为C++开发者的专业技能。