C++的异常处理机制允许程序在运行过程中遇到错误时抛出特定类型的异常，通过捕获和处理异常来规避程序崩溃，但如果异常没有被正确拦截或者处理流程存在缺陷，就会出现异常泄漏的问题，导致资源泄漏、程序逻辑异常等后果。
C++异常处理的基本运作逻辑
C++的异常处理主要通过三个关键字实现：throw用于抛出异常，try包裹可能抛出异常的代码块，catch用于捕获并处理对应类型的异常。当try块中的代码抛出异常后，程序会暂停当前执行流程，沿着调用栈向上查找匹配的catch块，如果找到则执行处理逻辑，找不到则会导致程序调用std::terminate终止运行。
下面是一个基础的函数异常处理示例：
#include <iostream>
#include <stdexcept>
// 除法函数，除数为0时抛出异常
double divide(int a, int b) {
if (b == 0) {
throw std::invalid_argument("除数不能为0");
}
return (double)a / b;
}
int main() {
try {
double result = divide(10, 0);
std::cout << "计算结果：" << result << std::endl;
} catch (const std::invalid_argument& e) {
// 捕获并处理异常
std::cout << "捕获到异常：" << e.what() << std::endl;
}
return 0;
}
异常泄漏的常见场景
异常泄漏并不是指异常对象本身的内存泄漏，而是指异常未被正确捕获，或者处理过程中引发新的问题，导致程序出现不符合预期的行为，常见场景有以下几种：
- 函数抛出异常后，没有对应的
catch块捕获，导致异常沿着调用栈传递到最外层，触发程序终止。 - 在构造函数中抛出异常，导致已经分配的资源无法被析构函数释放，出现资源泄漏。
- 在析构函数中抛出异常，如果此时程序正在处理另一个异常，会导致
std::terminate被调用。 - 异常被捕获后没有做任何处理，直接忽略，导致错误没有被修复，后续逻辑继续运行引发更严重的问题。
防止异常泄漏的核心方法
1. 使用RAII技术管理资源
RAII（资源获取即初始化）是C++中防止资源泄漏和异常泄漏的核心思想，它将资源的生命周期和对象的生命周期绑定，对象构造时获取资源，析构时自动释放资源，即使中途抛出异常，已经构造的对象也会被正确析构，资源也会随之释放。
比如手动管理动态内存时，如果new之后抛出异常，就会导致内存泄漏：
#include <iostream>
void func_with_leak() {
int* p = new int(10);
// 如果这里抛出异常，p指向的内存不会被释放，出现泄漏
throw std::runtime_error("函数执行出错");
delete p; // 永远不会执行到
}
int main() {
try {
func_with_leak();
} catch (...) {
std::cout << "捕获到异常" << std::endl;
}
return 0;
}
改用RAII方式，使用智能指针管理内存就可以避免这个问题：
#include <iostream>
#include <memory>
void func_no_leak() {
// 智能指针构造时获取资源，析构时自动释放
std::unique_ptr<int> p = std::make_unique<int>(10);
throw std::runtime_error("函数执行出错");
// 即使抛出异常，p的析构函数会被调用，内存自动释放
}
int main() {
try {
func_no_leak();
} catch (...) {
std::cout << "捕获到异常，内存已自动释放" << std::endl;
}
return 0;
}
2. 避免析构函数抛出异常
析构函数不应该抛出异常，因为如果在栈展开（处理异常的过程中销毁局部对象）时析构函数抛出异常，程序会直接调用std::terminate终止。如果析构函数中可能出现错误，应该捕获异常并做日志记录，不要让异常抛出。
#include <iostream>
#include <fstream>
class FileHandler {
private:
std::ofstream file;
public:
FileHandler(const char* filename) {
file.open(filename);
if (!file.is_open()) {
throw std::runtime_error("文件打开失败");
}
}
~FileHandler() {
try {
if (file.is_open()) {
file.close();
}
} catch (...) {
// 捕获析构中的异常，避免抛出
std::cout << "关闭文件时出现错误" << std::endl;
}
}
};
3. 合理使用异常捕获和处理
对于可能抛出异常的函数，应该在合适的层级使用try-catch块捕获异常，不要过度捕获，也不要完全不捕获。如果当前函数无法处理异常，可以通过异常规范（C++11之后使用noexcept）明确函数是否会抛出异常，方便调用方处理。
C++11之后使用noexcept标识不会抛出异常的函数：
#include <iostream>
// 标识该函数不会抛出异常
void safe_func() noexcept {
int a = 10;
int b = 20;
// 函数内不会抛出异常
}
// 可能抛出异常的函数
void unsafe_func() {
throw std::runtime_error("出错了");
}
int main() {
try {
unsafe_func();
} catch (const std::exception& e) {
std::cout << "处理函数异常：" << e.what() << std::endl;
}
return 0;
}
4. 异常捕获后不要忽略错误
捕获到异常后，应该做对应的处理，比如修复错误、记录日志、返回错误状态等，不要直接空捕获，否则异常被吞掉，错误没有被处理，后续逻辑可能基于错误状态运行，引发更严重的问题。
错误的空捕获示例：
#include <iostream>
#include <stdexcept>
void bad_catch() {
try {
throw std::runtime_error("业务错误");
} catch (...) {
// 空捕获，异常被忽略，没有任何处理
}
// 后续逻辑继续运行，可能基于错误状态执行
std::cout << "继续执行后续逻辑" << std::endl;
}
正确的处理方式应该根据业务需求做对应处理：
#include <iostream>
#include <stdexcept>
#include <fstream>
void good_catch() {
try {
throw std::runtime_error("业务错误");
} catch (const std::exception& e) {
// 记录错误日志
std::ofstream log("error.log", std::ios::app);
log << "捕获到异常：" << e.what() << std::endl;
// 可以选择重新抛出异常交给上层处理
throw;
}
}
总结
防止C++函数中的异常泄漏，核心是从资源管理和异常处理流程两方面入手，优先使用RAII技术绑定资源生命周期，避免手动管理资源带来的泄漏风险；同时注意析构函数不要抛出异常，合理设计异常捕获层级，不要忽略捕获到的异常。通过这些方法，可以有效避免异常泄漏导致的程序问题，提升代码的健壮性。