C++函数异常发生时如何正确释放已分配的内存

在C++编程中，函数执行时可能因为参数不合法、运行条件不满足等原因抛出异常，如果此时函数已经提前分配了堆内存，常规的末尾释放逻辑就会被跳过，引发内存泄漏。

异常导致内存泄漏的常见场景

先看一个简单的错误示例，在函数内部分配内存后，没有考虑异常场景的释放逻辑：

#include <iostream>
#include <stdexcept>

void wrong_memory_release() {
    int* arr = new int[10]; // 分配堆内存
    // 模拟函数执行过程中抛出异常
    if (true) {
        throw std::runtime_error("函数执行出错");
    }
    // 下面的释放逻辑永远不会执行，arr指向的内存泄漏
    delete[] arr;
}

int main() {
    try {
        wrong_memory_release();
    } catch (const std::exception& e) {
        std::cout << "捕获到异常: " << e.what() << std::endl;
    }
    return 0;
}

上面的代码中，new int[10]分配的内存永远不会被释放，这就是异常场景下的典型内存泄漏问题。

方案一：使用try-catch手动捕获释放

最简单的解决思路是在函数内部捕获异常，释放内存后再重新抛出：

#include <iostream>
#include <stdexcept>

void try_catch_release() {
    int* arr = new int[10];
    try {
        // 模拟可能抛出异常的逻辑
        if (true) {
            throw std::runtime_error("函数执行出错");
        }
        // 正常逻辑执行完成，释放内存
        delete[] arr;
    } catch (...) {
        // 捕获所有异常，先释放内存，再重新抛出
        delete[] arr;
        throw;
    }
}

int main() {
    try {
        try_catch_release();
    } catch (const std::exception& e) {
        std::cout << "捕获到异常: " << e.what() << std::endl;
    }
    return 0;
}

这种方式可以解决问题，但如果函数内部分配的资源变多，或者有多处可能抛异常的逻辑，就需要写很多重复的捕获释放代码，维护成本较高。

方案二：使用RAII机制管理资源

RAII（资源获取即初始化）是C++推荐的资源管理方式，核心思路是把资源封装到类的对象中，利用对象的构造函数获取资源，析构函数释放资源，因为C++保证对象离开作用域时会自动调用析构函数，即使发生异常也会执行。

我们可以自己封装一个简单的数组资源管理类：

#include <iostream>
#include <stdexcept>

// 简单的RAII数组封装类
class IntArray {
private:
    int* data;
public:
    // 构造函数分配资源
    IntArray(size_t size) : data(new int[size]) {}
    // 析构函数释放资源
    ~IntArray() {
        delete[] data;
        std::cout << "数组内存已释放" << std::endl;
    }
    // 提供访问接口
    int* get() const { return data; }
};

void raii_release() {
    IntArray arr(10); // 对象构造时分配内存
    // 模拟抛出异常
    if (true) {
        throw std::runtime_error("函数执行出错");
    }
    // 正常执行时，arr离开作用域会自动调用析构函数释放内存
}

int main() {
    try {
        raii_release();
    } catch (const std::exception& e) {
        std::cout << "捕获到异常: " << e.what() << std::endl;
    }
    return 0;
}

这种方式把资源释放逻辑和类绑定，不需要手动写释放代码，大大降低了出错概率。

方案三：使用标准智能指针

C++标准库已经提供了成熟的智能指针，不需要自己封装RAII类，最常用的是std::unique_ptr和std::shared_ptr，对于数组场景可以使用对应的数组版本。

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

void smart_ptr_release() {
    // unique_ptr管理数组，指定删除器为delete[]
    std::unique_ptr<int[]> arr(new int[10]);
    // 也可以直接用make_unique（C++14及以上）
    // auto arr = std::make_unique<int[]>(10);
    // 模拟抛出异常
    if (true) {
        throw std::runtime_error("函数执行出错");
    }
    // 离开作用域时，unique_ptr自动释放内存
}

int main() {
    try {
        smart_ptr_release();
    } catch (const std::exception& e) {
        std::cout << "捕获到异常: " << e.what() << std::endl;
    }
    return 0;
}

智能指针是实际开发中最推荐的方式，不需要手动管理内存生命周期，异常发生时也会自动释放资源，既安全又简洁。

不同方案对比

在实际开发中，优先选择标准智能指针管理内存资源，从根源上避免异常场景下的内存泄漏问题，让代码更健壮易维护。

C++异常资源管理内存释放RAII智能指针修改时间：2026-05-29 16:48:56