程序因错误提前退出时，动态内存（含CUDA）的正确释放方式

你提到的这种场景——多次动态分配后，中间步骤出错导致已分配资源无法释放——在C语言和CUDA开发里非常常见，尤其是CUDA涉及主机/设备双重内存管理，出错时的资源清理更需要严谨处理。下面给你几种实用的解决方案，从简单直接到更易维护的结构：

一、合理使用goto实现集中式清理（推荐C/CUDA场景） #

虽然goto常被诟病，但在资源清理这个特定场景下，它是业界公认的合理用法（甚至C语言经典书籍《K&R》也提及过这种模式）。核心思路是：把所有资源释放的代码集中到一个统一的退出区块，任何出错的地方都跳转到这里，根据已分配的资源状态逐一释放，从根源上避免重复代码。

针对你最初的矩阵分配示例： #

int main(const int argc, const char *argv[]) {
    int *A = NULL;
    int *B = NULL;
    // 读取M、N、K、L的逻辑...

    if (M*N < 1000000) {
        A = malloc(M*N * sizeof(int));
        if (A == NULL) {
            printf("Failed to allocate array A!\n");
            goto cleanup;
        }
    } else {
        printf("Matrix A will be too large!\n");
        goto cleanup;
    }

    if (K*L < 1000000) {
        B = malloc(K*L * sizeof(int));
        if (B == NULL) {
            printf("Failed to allocate array B!\n");
            goto cleanup;
        }
    } else {
        printf("Matrix B will be too large!\n");
        goto cleanup;
    }

    // 执行数组逐元素相乘等业务逻辑...

cleanup:
    // 释放已分配资源，NULL指针传入free是安全的
    if (A != NULL) free(A);
    if (B != NULL) free(B);
    // 根据资源分配状态返回对应错误码
    return (A == NULL || B == NULL) ? 1 : 0;
}

这种方式改动极小，完全符合你“无法重构代码”的限制，后续新增资源时只需要在cleanup块里添加对应的释放语句即可。

二、针对CUDA场景的适配方案 #

CUDA的cudaMalloc/cudaFree、cudaMemcpy都可能返回错误，同样可以用集中式清理的思路，同时注意区分主机内存和设备内存的释放逻辑：

int main() {
    double *host_I = NULL;
    double *dev_I = NULL;
    cudaError_t err = cudaSuccess;
    int M = ..., N = ...; // 初始化矩阵尺寸

    // 分配主机内存
    host_I = malloc(M*N * sizeof(double));
    if (host_I == NULL) {
        printf("Host memory allocation failed!\n");
        goto cleanup;
    }

    // 分配设备内存（注意cudaMalloc的参数格式：双指针 + 总字节数）
    err = cudaMalloc(&dev_I, M*N * sizeof(double));
    if (err != cudaSuccess) {
        printf("Error allocating dev_I: %s\n", cudaGetErrorString(err));
        goto cleanup;
    }

    // 主机到设备的数据拷贝
    err = cudaMemcpy(dev_I, host_I, M*N * sizeof(double), cudaMemcpyHostToDevice);
    if (err != cudaSuccess) {
        printf("Error copying data to dev_I: %s\n", cudaGetErrorString(err));
        goto cleanup;
    }

    // 执行CUDA核函数计算等逻辑...

cleanup:
    // 优先释放设备内存
    if (dev_I != NULL) cudaFree(dev_I);
    // 再释放主机内存
    if (host_I != NULL) free(host_I);
    // 返回错误码
    return (err != cudaSuccess || host_I == NULL) ? 1 : 0;
}

这里有几个关键细节：

• 所有资源指针初始化为NULL，因为cudaFree(NULL)和free(NULL)都是安全操作，不会触发错误
• 用cudaGetErrorString(err)打印具体错误信息，大幅提升调试效率
• 所有错误分支统一跳转到cleanup块，确保已分配的资源不会遗漏

三、进阶：封装清理函数（适合资源较多的场景） #

如果你的程序需要管理大量资源，可以把清理逻辑封装成独立函数，避免cleanup块过于冗长：

void cleanup_cuda_resources(double *host_ptr, double *dev_ptr) {
    if (dev_ptr != NULL) cudaFree(dev_ptr);
    if (host_ptr != NULL) free(host_ptr);
}

int main() {
    double *host_I = NULL;
    double *dev_I = NULL;
    cudaError_t err = cudaSuccess;

    // ...内存分配、数据拷贝逻辑...
    if (err != cudaSuccess) {
        printf("CUDA error: %s\n", cudaGetErrorString(err));
        cleanup_cuda_resources(host_I, dev_I);
        return 1;
    }

    // ...业务逻辑...

    cleanup_cuda_resources(host_I, dev_I);
    return 0;
}

这种方式更模块化，但如果资源类型或数量频繁变化，需要同步更新清理函数的参数，适合资源结构相对稳定的场景。

为什么不推荐在每个错误分支单独释放？ #

你提到的在每个错误分支手动添加free(A)的方式，当资源数量增多时（比如3个、5个甚至更多动态分配的数组/设备内存），会导致代码重复度极高，而且极易遗漏——比如新增了一个资源，却忘记在某个错误分支里添加对应的释放语句，最终还是会出现内存泄漏。集中式清理的方式从根本上解决了这个问题。

内容的提问来源于stack exchange，提问作者Floris