【C++】 异常处理

---

C++ 异常处理完整深度解析

一、异常基础语法：try /throw/catch

1. 完整语法结构

try {
    // 正常业务代码，可能抛出异常
    throw 异常实例;
}
catch (异常类型1 参数) {
    // 处理类型1的错误
}
catch (异常类型2 &参数) {
    // 推荐引用捕获，避免对象拷贝切片
}
catch (...) {
    // 万能捕获，捕获所有未匹配异常，兜底处理
}

• try****：划定「受监控代码块」，块内抛出的异常才会被后续 catch 捕获；
• throw****：主动抛出异常对象，中断当前代码执行，触发栈展开；
• catch****：匹配对应类型的异常，处理错误逻辑；无匹配 catch 程序直接调用 std::terminate 崩溃。

2. throw 可以抛出任意类型

C++ 对抛出对象无类型限制，基础类型、字符串、自定义类、标准异常类均可：

// 1. 抛出内置类型
throw -1;
throw false;

// 2. 抛出std::string
throw std::string("数组下标越界");

// 3. 工程推荐：抛出标准异常对象
throw std::runtime_error("除数不能为0");

3. catch 匹配核心规则（高频考点）

1. 严格类型匹配，不做隐式转换抛出 int 无法被 double、long 的 catch 捕获；抛出子类不能先写父类 catch，否则子类永远无法匹配。错误示范：

   try { throw std::out_of_range("越界"); }
   // 父类在前，子类直接失效
   catch(std::exception& e) {}
   catch(std::out_of_range& e) {}

   正确顺序：子类异常在前，基类异常在后。

2. 捕获优先使用引用 &直接值捕获会拷贝异常对象，带来性能损耗；基类值捕获会发生对象切片，丢失子类独有的错误信息。标准写法：catch(std::exception &e)

3. catch(...) 万能捕获只能放在最后仅用于兜底、打印日志、统一释放资源，无法获取异常具体信息。

---

二、栈展开 Stack Unwinding：异常核心底层机制

1. 什么是栈展开？

当执行 throw 抛出异常时，编译器会从抛出点反向遍历函数调用栈：

1. 销毁当前 try 块内所有局部栈对象，自动调用析构函数；
2. 逐层退出上层函数，销毁每层局部变量；
3. 直到找到能匹配当前异常类型的 catch 块，停止栈展开，进入异常处理逻辑；
4. 若遍历完整个调用栈仍无匹配 catch，调用 std::terminate() 终止程序。

2. 栈展开最大价值：自动释放资源，配合 RAII 实现异常安全

C 语言出错时必须手动 free、fclose，一旦提前 return 或出错，极易遗漏释放； C++ 局部对象出作用域自动析构，栈展开过程会强制执行析构，裸指针会泄漏，智能指针不会。

void badFunc() {
    int* p = new int[100];
    throw std::runtime_error("出错");
    // 栈展开只销毁局部变量p（指针本身），不会释放堆内存，内存泄漏！
}

void goodFunc() {
    std::unique_ptr<int[]> p(new int[100]);
    throw std::runtime_error("出错");
    // unique_ptr析构时自动delete堆内存，无泄漏
}

结论：工程中禁止裸指针管理堆资源，必须使用 RAII 容器 / 智能指针，保证异常安全。

---

三、C++ 标准异常体系 <stdexcept>

所有标准异常均继承自顶层基类 std::exception，定义头文件 <stdexcept>，基类提供虚函数 virtual const char* what() const noexcept，返回字符串形式错误描述。

1. 两大异常分支

（1）逻辑异常 logic_error：代码逻辑错误，开发阶段即可规避

属于程序编写失误，正常测试场景应提前拦截，理论上不应该在线上抛出

• invalid_argument：函数传入非法参数
• out_of_range：容器下标、数组越界访问
• domain_error：数学函数定义域非法（如负数开平方根）
• length_error：容器容量超出最大限制

（2）运行时异常 runtime_error：运行环境不可预测故障

外部环境导致，无法单纯靠代码规避，线上高频出现

• range_error：数值计算结果超出值域范围
• overflow_error：算术运算上溢
• underflow_error：算术运算下溢

2. 标准异常完整使用示例

#include <iostream>
#include <stdexcept>

double divide(int a, int b) {
    if (b == 0) {
        // 运行时错误：除数为0
        throw std::runtime_error("Divide by zero error");
    }
    return static_cast<double>(a) / b;
}

int main() {
    try {
        divide(10, 0);
    } catch (std::runtime_error &err) {
        // what() 获取错误信息
        std::cout << "捕获异常：" << err.what() << std::endl;
    } catch (std::exception &err) {
        // 兜底捕获所有标准异常
        std::cout << "通用异常：" << err.what() << std::endl;
    }
    return 0;
}

---

四、自定义异常类（项目开发必备）

标准异常仅提供通用错误描述，大型项目需要区分模块错误（数据库异常、网络异常、文件异常），通过继承 std::exception 实现自定义异常。

完整自定义异常模板

#include <exception>
#include <string>

// 数据库模块专属异常
class DBException : public std::exception {
private:
    std::string err_msg;
public:
    // 构造函数接收自定义错误信息
    explicit DBException(const std::string& msg) : err_msg(msg) {}

    // 重写虚函数what，加noexcept保证不抛异常
    const char* what() const noexcept override {
        return err_msg.c_str();
    }
};

// 使用
void sqlQuery() {
    bool connectFail = true;
    if (connectFail) {
        throw DBException("数据库连接超时，端口无法访问");
    }
}

优势

1. 区分业务错误类型，catch 时精准定位故障模块；
2. 可扩展成员：错误码、错误堆栈、请求 ID，方便日志排查；
3. 完全兼容标准异常捕获逻辑。

---

五、异常修饰符：noexcept

1. 过时语法：动态异常说明（C++17 标准删除）

早期 C++ 使用 throw(类型列表) 声明函数允许抛出的异常：

// 仅能抛出int、string
void oldFunc() throw(int, std::string);
// 承诺不抛出任何异常
void noThrowFunc() throw();

缺陷**：编译器不做强制检查，运行时抛出未声明异常直接崩溃，可读性差，新标准彻底废弃。**

2. C++11 noexcept 关键字（工程唯一推荐）

两种用法

1. noexcept：函数承诺不会抛出任何异常

void safeFunc() noexcept;

1. noexcept(布尔表达式)：条件式无异常，表达式为 true 则等价 noexcept

template<typename T>
void swap(T& a, T& b) noexcept(noexcept(a.swap(b)));

关键规则

1. 标记 noexcept 的函数内部若抛出异常，程序直接调用 std::terminate，不会进入任何 catch；
2. C++ 隐式规定：析构函数默认 noexcept；如果析构抛出异常，栈展开过程会直接终止程序，属于严重 bug；
3. 优化价值：编译器可对 noexcept 函数做性能优化，不需要生成异常跳转表。

工程强制规范

• 资源释放函数、析构、内存回收函数一律加 noexcept；
• 纯计算、无 IO、无错误场景函数标记 noexcept。

---

六、异常进阶：重新抛出异常 throw;

捕获异常后，有时需要先打印日志、释放临时资源，再将异常向上层业务传递，分为两种重抛方式：

1. throw; 无参数：原样重抛原有异常，保留完整子类信息（推荐）
2. throw 新对象; 生成全新异常，丢失原有异常上下文

try {
    throw std::out_of_range("数组下标100越界");
} catch (std::exception &e) {
    std::cout << "记录错误日志：" << e.what() << std::endl;
    throw; // 重抛原始out_of_range异常，上层可精准捕获
}

---

七、三大异常安全保证（面试核心考点）

编写异常安全代码分为三个等级，项目开发最低要求满足基础保证，核心业务建议强保证。

1. 无抛出保证（No-throw guarantee）函数标记 noexcept，运行全程绝对不会抛出异常；如析构、内存释放、swap 交换函数。

2. 基础保证（Basic guarantee）抛出异常后：程序不崩溃、无内存 / 句柄泄漏、对象处于合法可用状态，但中间修改可能保留。大部分常规函数最低标准。

3. **强保证（Strong guarantee）事务型语义：要么函数完整执行成功，所有修改生效；抛出异常时，所有状态回滚到函数调用前，无任何副作用。**实现方案：先在临时变量完成所有修改，全部逻辑无异常后，再交换到原对象。

---

八、工程最佳实践 & 高频踩坑总结

最佳实践

1. 异常仅处理罕见错误，不用代替普通判断异常底层存在性能开销，不要用异常处理常规业务分支（如用户输入为空、查询结果为空），这类场景用 if 判断；异常用于不可预期故障：断网、数据库崩溃、内存耗尽。

2. 永远不要在析构函数中抛出异常栈展开过程中若析构抛异常，会同时存在两个未处理异常，程序直接终止。析构内出错仅打印日志，禁止 throw。

3. 抛出对象，禁止抛出栈对象地址错误：throw &localErr;，栈展开后局部对象销毁，外部捕获到野指针；直接抛出值对象。

4. 分层捕获异常，底层抛标准 / 自定义异常，顶层统一兜底底层函数精准抛出细分异常，业务层 catch 对应类型处理，main 函数加catch(...)防止程序直接闪退。

5. RAII 优先，所有资源使用智能指针、容器管理杜绝裸 new/delete，避免栈展开内存泄漏。

常见致命坑

1. catch 值捕获导致对象切片，丢失子类错误信息；
2. catch 顺序颠倒，父类异常写在子类前面；
3. noexcept 函数内部抛出异常，程序无提示直接崩溃；
4. 函数仅靠返回值报错，混合异常，代码逻辑混乱；
5. 抛出局部变量指针，产生野指针；
6. 循环、高频接口频繁抛出异常，带来巨大性能损耗。

---