C++ 异常处理（深入浅出）

C++ 异常处理：从崩溃到优雅容错的进阶之路

在编写 C++ 程序时，你是否遇到过这样的场景：程序运行到一半突然崩溃，控制台弹出“Segmentation fault”或“Access violation”，而你却一头雾水，不知道问题出在哪儿？这背后，往往是因为程序没有对异常情况进行妥善处理。C++ 异常处理机制，正是为了解决这类“突发状况”而设计的系统性方案。它不是魔法，但却是让代码更健壮、更易维护的重要工具。

想象一下，你正在开车。正常行驶时，一切顺利；但突然前方出现一个坑洼，如果不做任何反应，车可能会失控翻车。而“异常处理”就像车载的主动安全系统——它能感知到异常（比如颠簸），并自动启动应对机制（比如自动刹车、调整悬挂），让你平稳度过难关。C++ 的异常处理机制，正是为程序“感知”和“应对”运行时错误而存在的。

本文将带你从零开始，系统掌握 C++ 异常处理的核心机制，包括基本语法、常见陷阱、最佳实践和实际应用场景，帮助你写出更安全、更可靠的代码。

异常处理的基本语法与流程

C++ 异常处理基于三个关键字：try、catch 和 throw。它们构成了一个完整的错误处理流程，就像一个“报警-响应-处理”的闭环系统。

• throw：抛出异常，相当于发出“警报”。
• try：包裹可能出错的代码块，表示“我在这里尝试执行，如果出事，请通知我”。
• catch：捕获并处理异常，相当于“接收到警报后，我来处理”。

下面是一个最基础的示例：

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("除数不能为零！");  // 抛出异常：当 b 为 0 时，触发错误
    }
    return a / b;
}

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

    return 0;
}

代码注释说明：

• throw std::runtime_error("...")：当除数为 0 时，抛出一个标准异常对象。
• try 块中包含可能引发异常的代码，这里是 divide(10, 0)。
• catch (const std::runtime_error& e)：捕获类型为 std::runtime_error 的异常，e.what() 返回错误描述字符串。
• std::cerr 用于输出错误信息，区别于 std::cout 的正常输出。

运行结果会显示：

捕获到异常：除数不能为零！

这表明程序没有崩溃，而是优雅地处理了异常。这就是 C++ 异常处理的“第一道防线”。

异常的类型与继承体系

C++ 的异常可以是任意类型，但通常我们使用标准库提供的异常类。这些类构成了一个继承体系，便于分类处理。

#include <iostream>
#include <stdexcept>

void riskyFunction(int* ptr) {
    if (ptr == nullptr) {
        throw std::logic_error("指针不能为空！");  // 逻辑错误：违反前提条件
    }
    *ptr = 100;
}

int main() {
    int* p = nullptr;

    try {
        riskyFunction(p);  // 会抛出异常
    } catch (const std::exception& e) {
        // 捕获所有标准异常的基类
        std::cerr << "异常类型：" << typeid(e).name() << std::endl;
        std::cerr << "错误信息：" << e.what() << std::endl;
    }

    return 0;
}

代码注释说明：

• typeid(e).name()：获取异常对象的实际类型名称，用于调试。
• 使用 const std::exception& 捕获所有派生异常，是常见的做法，避免重复写多个 catch 块。

💡 提示：尽量使用标准异常类，避免自定义异常时忘记实现 what() 方法。

多个 catch 块的使用与异常匹配机制

一个 try 块可以对应多个 catch 块，C++ 会按顺序匹配异常类型。匹配原则是：最具体（最派生）的异常类型优先匹配。

#include <iostream>
#include <stdexcept>

void process(int value) {
    if (value < 0) {
        throw std::invalid_argument("输入值不能为负数");
    }
    if (value > 100) {
        throw std::out_of_range("输入值超出范围");
    }
    std::cout << "处理成功，值为：" << value << std::endl;
}

int main() {
    try {
        process(-5);  // 抛出 invalid_argument
    } catch (const std::out_of_range& e) {
        std::cerr << "范围错误：" << e.what() << std::endl;
    } 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;
}

代码注释说明：

• 尽管 invalid_argument 和 out_of_range 都是 std::exception 的派生类，但 catch 块顺序很重要。
• out_of_range 的 catch 块在 invalid_argument 之前，但 invalid_argument 会先匹配，因为抛出的是这个类型。
• 最后一个 catch (const std::exception&) 作为“兜底”机制，捕获所有未被前面处理的异常。

这种设计让你可以精确控制异常处理逻辑，避免“一刀切”。

异常安全与 RAII 的结合使用

仅仅抛出异常还不够，关键是要保证程序状态的正确性。这引出了“异常安全”（Exception Safety）的概念。

C++ 的 RAII（Resource Acquisition Is Initialization）机制是实现异常安全的核心。它确保资源（如内存、文件句柄、锁）在对象生命周期结束时自动释放，即使发生异常也不会泄漏。

#include <iostream>
#include <memory>
#include <fstream>

class FileManager {
public:
    FileManager(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("无法打开文件：" + filename);
        }
        std::cout << "文件 " << filename << " 已打开" << std::endl;
    }

    ~FileManager() {
        if (file.is_open()) {
            file.close();
            std::cout << "文件已关闭" << std::endl;
        }
    }

    void writeData(const std::string& data) {
        if (file.is_open()) {
            file << data << std::endl;
        } else {
            throw std::runtime_error("文件未打开，无法写入");
        }
    }

private:
    std::ofstream file;
};

int main() {
    try {
        FileManager fm("output.txt");
        fm.writeData("Hello, World!");
        throw std::runtime_error("模拟异常发生");  // 模拟运行中出错
    } catch (const std::exception& e) {
        std::cerr << "捕获异常：" << e.what() << std::endl;
    }

    return 0;
}

代码注释说明：

• FileManager 构造函数中打开文件，失败则抛异常。
• ~FileManager() 自动关闭文件，无论是否抛异常，都会执行。
• 即使 writeData 后抛出异常，析构函数仍会被调用，文件资源不会泄漏。

这就是 RAII 的威力：资源的获取和释放与对象生命周期绑定，异常发生时，析构函数自动执行，保证了资源安全。

实战场景：日志系统中的异常处理

在真实项目中，异常处理常用于日志、配置读取、网络请求等场景。下面是一个典型的配置加载示例：

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

class ConfigLoader {
public:
    std::map<std::string, std::string> loadConfig(const std::string& filename) {
        std::map<std::string, std::string> config;
        std::ifstream file(filename);

        if (!file.is_open()) {
            throw std::runtime_error("配置文件 " + filename + " 不存在或无法读取");
        }

        std::string line;
        while (std::getline(file, line)) {
            // 跳过空行和注释
            if (line.empty() || line[0] == '#') continue;

            size_t pos = line.find('=');
            if (pos == std::string::npos) {
                throw std::invalid_argument("配置格式错误，缺少等号：" + line);
            }

            std::string key = line.substr(0, pos);
            std::string value = line.substr(pos + 1);

            config[key] = value;
        }

        file.close();
        return config;
    }
};

int main() {
    ConfigLoader loader;
    try {
        auto config = loader.loadConfig("config.ini");
        std::cout << "配置加载成功，共 " << config.size() << " 项" << std::endl;
        for (const auto& pair : config) {
            std::cout << pair.first << " = " << pair.second << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "配置加载失败：" << e.what() << std::endl;
        return -1;
    }

    return 0;
}

代码注释说明：

• 读取配置文件时，检查文件是否存在、格式是否正确。
• 使用 std::map 存储键值对，便于后续使用。
• 所有异常都由 catch 块统一处理，程序不会崩溃。
• 如果配置文件格式错误（如 key=value 缺少等号），会抛出 invalid_argument。

这个例子展示了 C++ 异常处理在实际项目中的价值：让程序在面对外部输入错误时，依然能稳定运行并提供有意义的反馈。

总结：让代码具备“抗打击能力”

C++ 异常处理不是为了“避免错误”，而是为了在错误发生时，程序能有条不紊地应对，而不是瞬间崩溃。它是一种“防御性编程”的体现。

• 使用 try-catch 捕获异常，避免程序中断。
• 优先使用标准异常类，提高代码可读性和可维护性。
• 配合 RAII 机制，确保资源不泄漏。
• 在关键模块（如 I/O、网络、配置）中合理使用异常处理。
• 避免在函数中“吞掉”异常而不处理，这是危险的。

记住：一个成熟的 C++ 程序，不在于它从不报错，而在于它在出错时，依然能优雅地运行或提供清晰的错误提示。

当你熟练掌握 C++ 异常处理后，你会发现，程序的健壮性不再是“运气”，而是“设计”。这正是高级开发者与初学者的分水岭。