C++ 异常处理库 <exception>（详细教程）

C++ 异常处理库 的核心机制与实战应用

在 C++ 编程中，程序运行时的错误处理一直是一个关键问题。传统的错误返回机制（如函数返回 -1 或 nullptr）虽然简单，但容易被忽略，导致程序崩溃或逻辑混乱。而 C++ 异常处理库 的出现，正是为了解决这类问题。它提供了一套标准化、可预测的错误传递机制，让你的代码更健壮、更易于维护。

想象一下，你正在写一个计算器程序，用户输入了一个除以零的操作。如果不做异常处理，程序很可能直接崩溃。但使用 C++ 异常处理库 ，你可以优雅地捕获这个错误，提示用户“除数不能为零”，然后继续运行，而不是让整个程序“罢工”。

什么是 C++ 异常处理库

C++ 异常处理库 是标准库中用于异常处理的核心头文件。它定义了异常类的基类 std::exception，以及其他常用异常类型，如 std::bad_alloc（内存分配失败）、std::bad_cast（类型转换失败）等。这些异常类都继承自 std::exception，形成了一个统一的异常体系。

这个库的作用就像一个“错误快递员”：当程序中出现异常时，它会把错误信息“打包”并“快递”到最近的异常处理代码块中。你不需要在每个函数里检查返回值，而是可以集中在一个地方处理错误，让代码逻辑更清晰。

核心关键字：try、catch、throw

C++ 异常处理依赖于三个关键字：try、catch 和 throw。

• try：用于包裹可能抛出异常的代码块。
• throw：用于抛出一个异常对象，表示发生了错误。
• catch：用于捕获并处理异常，紧跟在 try 块之后。

#include <iostream>
#include <exception>

// 模拟一个可能出错的函数
void divide(int a, int b) {
    if (b == 0) {
        // 抛出一个标准异常对象
        throw std::runtime_error("除数不能为零！");
    }
    std::cout << "结果是: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 0);  // 这里会抛出异常
    } catch (const std::exception& e) {
        // 捕获异常并输出错误信息
        std::cerr << "捕获到异常: " << e.what() << std::endl;
    }

    std::cout << "程序继续运行..." << std::endl;
    return 0;
}

代码注释说明：

• throw std::runtime_error("除数不能为零！");：抛出一个 runtime_error 异常，它继承自 std::exception，用于运行时错误。
• catch (const std::exception& e)：捕获所有继承自 std::exception 的异常，e.what() 返回异常的描述字符串。
• 程序在抛出异常后，会立即跳转到 catch 块，try 块中剩余代码不再执行。

常见异常类型与使用场景

C++ 标准库中定义了多种异常类型，它们各自对应不同的错误场景。了解这些类型，有助于你选择合适的异常进行抛出。

#include <iostream>
#include <stdexcept>
#include <memory>

void process_data(const std::vector<int>& data) {
    if (data.empty()) {
        // 逻辑错误：数据为空，不符合业务逻辑
        throw std::logic_error("数据不能为空");
    }

    // 模拟内存分配
    std::unique_ptr<int[]> buffer = std::make_unique<int[]>(data.size());
    if (!buffer) {
        // 内存分配失败
        throw std::bad_alloc();
    }

    // 处理数据
    for (size_t i = 0; i < data.size(); ++i) {
        buffer[i] = data[i] * 2;
    }

    std::cout << "处理完成，数据已翻倍" << std::endl;
}

int main() {
    try {
        std::vector<int> empty_data;
        process_data(empty_data);  // 抛出 logic_error
    } catch (const std::exception& e) {
        std::cerr << "异常: " << e.what() << std::endl;
    }

    return 0;
}

代码注释说明：

• throw std::logic_error("数据不能为空");：当输入为空时抛出逻辑错误，表示程序的前置条件不满足。
• std::make_unique<int[]>(data.size())：智能指针管理内存，若分配失败会抛出 bad_alloc。
• catch 块统一处理所有标准异常，避免重复代码。

异常传播与栈展开

当你在函数 A 中抛出异常，而 A 没有 catch 块，异常会“向上”传播，直到找到合适的 catch 块。这个过程称为“栈展开”（stack unwinding）。

栈展开会自动调用所有局部对象的析构函数，确保资源被正确释放。这正是 C++ 异常处理比 C 语言 setjmp/longjmp 更安全的原因。

#include <iostream>
#include <exception>

class Resource {
public:
    Resource() {
        std::cout << "资源已分配" << std::endl;
    }
    ~Resource() {
        std::cout << "资源已释放" << std::endl;
    }
};

void risky_function() {
    Resource res;  // 局部对象
    std::cout << "执行中..." << std::endl;
    throw std::runtime_error("出错了！");
    // 即使这行不会执行，析构函数仍会被调用
}

int main() {
    try {
        risky_function();
    } catch (const std::exception& e) {
        std::cerr << "捕获异常: " << e.what() << std::endl;
    }

    std::cout << "程序结束" << std::endl;
    return 0;
}

输出结果：

资源已分配
执行中...
资源已释放
捕获异常: 出错了！
程序结束

关键点：即使函数提前抛出异常，Resource 对象的析构函数也会被调用，资源不会泄漏。

异常处理的最佳实践

1. 只抛出异常，不忽略：每个 throw 都应有对应的 catch，避免程序崩溃。
2. 使用具体异常类型：优先使用 std::runtime_error、std::logic_error 等，而不是 std::exception。
3. 避免在析构函数中抛出异常：析构函数中抛出异常可能导致程序终止。
4. 使用 RAII 机制：通过智能指针、RAII 类等管理资源，让异常安全更自然。

#include <iostream>
#include <stdexcept>

// 推荐做法：封装异常处理逻辑
void safe_divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("除数不能为零");
    }
    std::cout << "结果: " << a / b << std::endl;
}

int main() {
    try {
        safe_divide(10, 0);
    } catch (const std::invalid_argument& e) {
        std::cerr << "参数错误: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "未预期异常: " << e.what() << std::endl;
    }

    return 0;
}

说明：优先捕获更具体的异常类型，避免“大包大揽”式捕获。

总结与展望

C++ 异常处理库 是现代 C++ 编程中不可或缺的一部分。它不仅让错误处理更加优雅，还提升了代码的可读性与可维护性。通过合理使用 try、catch、throw，结合标准异常类，你可以构建出更加健壮的程序。

对于初学者来说，掌握异常处理的三大关键字是第一步；对于中级开发者，理解异常传播、栈展开和 RAII 的协同作用，则是迈向高质量 C++ 代码的关键一步。记住，异常不是“错误”，而是“控制流的另一种方式”。

在未来的 C++ 项目中，不妨从今天开始，为每一个可能出错的环节加上 try-catch，让程序在面对意外时，依然能从容应对。这才是 C++ 异常处理库 真正的价值所在。