C++ 异常处理（长文讲解）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程世界中，错误和意外情况如同生活中的突发事件，需要及时且优雅地应对。C++ 异常处理机制正是为此而生——它提供了一种结构化的方式，帮助开发者在程序运行时捕获并处理异常状态。无论是内存不足、文件读取失败，还是逻辑错误，异常处理都能让程序在崩溃前“救场”，从而提升代码的健壮性与可维护性。本文将从基础概念出发，结合代码示例和实际场景，系统讲解 C++ 异常处理的核心知识点，帮助开发者在项目中合理应用这一机制。

异常处理的基础概念

什么是异常？

异常（Exception）是程序运行过程中发生的非正常事件，例如除以零、内存分配失败或文件不存在。传统错误处理方式（如返回错误码）需要开发者在每一层代码中手动检查状态，这既繁琐又容易遗漏。而异常处理机制通过**抛出（Throw）和捕获（Catch）**的模式，将错误处理与正常逻辑分离，使代码结构更清晰。

C++ 异常处理的核心机制

C++ 的异常处理基于以下三个核心概念：

1. try 块：包裹可能抛出异常的代码区域。
2. catch 子句：定义如何捕获和处理特定类型的异常。
3. throw 表达式：主动抛出异常对象，触发异常流程。

可以将其想象为一场“突发事件”：

• try 是“监控现场”，负责监听异常的发生；
• throw 是“触发警报”，告知程序出现了意外；
• catch 是“应急小组”，根据警报类型采取对应措施。

try-catch 机制详解

try 块与 catch 子句的协作

#include <iostream>  
using namespace std;  

int main() {  
    try {  
        int a = 5, b = 0;  
        if (b == 0) throw "Division by zero!";  
        cout << "Result: " << a / b << endl;  
    } catch (const char* msg) {  
        cout << "Error: " << msg << endl;  
    }  
    cout << "Program continues..." << endl;  
    return 0;  
}  

代码解析：

• 当 b 为 0 时，throw 抛出一个字符串类型的异常对象。
• 程序立即跳转至最近的 catch 块，匹配异常类型后执行错误处理逻辑。
• 最终输出：

  Error: Division by zero!  
  Program continues...  
  

多 catch 子句的匹配规则

C++ 允许为不同异常类型设置多个 catch 块。匹配顺序遵循以下规则：

1. 精确匹配：优先捕获与异常类型完全一致的 catch。
2. 基类匹配：若无精确匹配，尝试捕获基类（如 catch(const exception&)）。
3. 通用捕获：最后才是 catch(...)，捕获所有未指定类型的异常。

示例：

try {  
    // ...  
} catch (int e) {  
    cout << "Caught integer error: " << e << endl;  
} catch (const exception& e) {  
    cout << "Caught standard exception: " << e.what() << endl;  
} catch (...) {  
    cout << "Unknown error!" << endl;  
}  

关键点：

• 多 catch 子句的排列顺序需谨慎，避免基类捕获“吞噬”派生类异常。
• catch(...) 应始终放在最后，否则会屏蔽所有后续的特定类型捕获。

异常的抛出与捕获

throw 表达式：异常的主动触发

throw 可以抛出任何类型对象，包括内置类型（如 int）、自定义类或标准库异常（如 std::runtime_error）。

// 抛出自定义错误码  
throw 404;  

// 抛出标准异常  
throw runtime_error("File not found");  

最佳实践：

• 避免抛出原始指针（可能导致内存泄漏）。
• 对于复杂错误信息，推荐使用继承自 std::exception 的自定义类。

异常传播与堆栈展开

当异常未被当前 try 块捕获时，控制权会逐级向上层函数回溯，直至找到匹配的 catch 或程序崩溃。这一过程称为堆栈展开（Stack Unwinding）。

注意：

• 堆栈展开时，局部对象的析构函数会被自动调用，确保资源释放（如关闭文件、释放内存）。
• 若析构函数中再次抛出异常，程序将终止（调用 terminate()）。

自定义异常类：构建更清晰的错误系统

继承 std::exception 的设计

通过继承 std::exception，开发者可以创建结构化、可扩展的异常类型。

#include <exception>  
#include <string>  

class InvalidInputException : public std::exception {  
private:  
    std::string message;  
public:  
    InvalidInputException(const std::string& msg) : message(msg) {}  
    const char* what() const noexcept override {  
        return message.c_str();  
    }  
};  

使用场景：

try {  
    string input = get_user_input();  
    if (input.empty()) throw InvalidInputException("Input cannot be empty");  
} catch (const InvalidInputException& e) {  
    cerr << "Custom error: " << e.what() << endl;  
}  

异常层次设计的建议

• 分层捕获：按异常严重程度分类（如 WarningException 和 FatalException）。
• 信息丰富：在 what() 返回中包含上下文（如文件名、行号）。
• 避免过度细分：过多异常类型会增加代码复杂度。

异常处理的注意事项

性能与资源管理

1. 频繁抛出的代价：异常机制涉及堆栈回溯，频繁使用可能导致性能下降。
   • 解决方案：对高频操作（如循环内）优先用条件判断替代。
2. 资源释放：
   • 使用 RAII（Resource Acquisition Is Initialization）模式，确保对象生命周期自动管理资源。
   • 避免在 catch 块中重复释放资源，可能导致双重释放。

需要规避的陷阱

• 切勿在析构函数中抛出异常：若析构函数执行时已有未处理异常，再次抛出会直接终止程序。
• 慎用 terminate()：默认异常处理函数 std::terminate() 可能导致程序非正常退出。
• 避免忽略异常：catch(...) 空块会隐藏错误，应至少记录日志。

典型应用场景与案例分析

案例 1：文件操作异常处理

#include <fstream>  

void read_file(const string& path) {  
    ifstream file(path);  
    if (!file.is_open()) throw runtime_error("Failed to open file");  
    // ...  
}  

int main() {  
    try {  
        read_file("nonexistent.txt");  
    } catch (const exception& e) {  
        cerr << "File error: " << e.what() << endl;  
        return 1;  
    }  
    return 0;  
}  

案例 2：网络请求超时处理

class NetworkTimeoutException : public runtime_error {  
public:  
    NetworkTimeoutException() : runtime_error("Network request timed out") {}  
};  

void send_request() {  
    if (check_timeout()) throw NetworkTimeoutException();  
    // ...  
}  

案例 3：输入验证

int get_positive_number() {  
    int num;  
    cin >> num;  
    if (num <= 0) throw invalid_argument("Number must be positive");  
    return num;  
}  

总结与最佳实践

通过本文的讲解，我们系统梳理了 C++ 异常处理的核心机制与实践方法。以下是关键总结：

1. 核心流程：通过 try-catch-throw 框架分离正常逻辑与错误处理。
2. 自定义异常：通过继承 std::exception 构建可扩展的错误系统。
3. 性能与安全：合理使用 RAII、避免析构函数抛出异常，平衡性能与可靠性。

最佳实践清单：

• 将异常视为“非预期事件”，而非常规控制流。
• 对关键资源（如文件、网络连接）使用 RAII 模式。
• 为不同错误类型设计层次化的异常类。
• 在 catch 块中记录日志，而非简单 return。

C++ 异常处理是构建健壮程序的重要工具，但需以谨慎的态度设计和使用。通过本文提供的案例与原则，开发者可以逐步掌握这一机制的精髓，为复杂项目奠定可靠的基础。