C语言中不同失败/退出点释放分配资源的良好编码实践

我正在做一个学校项目，老师要求我们在程序终止时释放所有资源。我正努力寻找一种更具可读性且代码量更少的资源管理方法，尤其考虑到不同退出点可能需要释放不同的资源，这让问题变得更复杂。目前最直接但杂乱的解决方案如下（退出点用返回-1的some_sys_call调用表示）：

char *a = malloc(1);
if(some_sys_call() == -1){
   free(a);
   return -1;
}
//b is needed until the end
char *b = malloc(1);
if(some_sys_call() == -1){
   free(a);
   free(b);
   return -1;
}
//c is needed until the end
char *c = malloc(1);
//a is no longer needed from here on, so it's freed right away
free(a);
if(some_sys_call() == -1){
   free(b);
   free(c);
   return -1;
}
//Exit point when there are no errors
free(b);
free(c);
return 0;

这种方案显然不尽人意：当资源较多时会产生大量重复代码，导致代码臃肿、可读性下降。当然，不能简单定义一个释放所有资源的宏或函数并在每个退出点调用，比如：

#define free_all  free(a); \
                  free(b); \
                  free(c);

理论上可以为不同的资源组合定义不同的宏或函数：

#define free_1 free(a); 

#define free_2 free(a); \
               free(b);
...

这会让核心代码更可读，但仍需编写大量不同的宏，也并非理想方案。请问这是一个常见问题吗？通常该如何处理？

这是C语言开发中非常常见的资源管理问题，尤其是在没有自动内存管理机制的情况下，手动处理多退出点的资源释放很容易写出冗余代码。以下是几种主流的简洁方案：

1. 统一退出点模式（Single Exit Point） #

把所有资源释放逻辑集中到函数末尾，通过标志变量控制流程，避免在每个错误点重复释放代码。

示例代码：

int result = 0;
char *a = NULL;
char *b = NULL;
char *c = NULL;

a = malloc(1);
if (a == NULL) {
    result = -1;
    goto cleanup;
}

if (some_sys_call() == -1) {
    result = -1;
    goto cleanup;
}

b = malloc(1);
if (b == NULL) {
    result = -1;
    goto cleanup;
}

if (some_sys_call() == -1) {
    result = -1;
    goto cleanup;
}

c = malloc(1);
if (c == NULL) {
    result = -1;
    goto cleanup;
}

// 不再需要a，提前释放
free(a);
a = NULL; // 避免后续重复释放

if (some_sys_call() == -1) {
    result = -1;
    goto cleanup;
}

cleanup:
    // 注意：free(NULL)是安全的，不需要额外判断
    free(a);
    free(b);
    free(c);
    return result;

这种模式的核心是用goto跳转到统一的cleanup块，所有资源释放都在这里处理，代码冗余度极低，可读性也更强。很多C标准库和成熟项目都在使用这种方案，不要被"goto有害"的旧观念束缚——在统一退出场景下，它是规范且高效的用法。

2. 资源封装与清理函数 #

为每组相关资源创建封装结构，搭配对应的清理函数，把释放逻辑模块化。

示例代码：

typedef struct {
    char *a;
    char *b;
    char *c;
} Resources;

void cleanup_resources(Resources *res) {
    if (res == NULL) return;
    free(res->a);
    free(res->b);
    free(res->c);
    // 如果结构本身是malloc分配的，也可以在这里free(res)
}

int main() {
    Resources res = {NULL, NULL, NULL};
    int result = 0;

    res.a = malloc(1);
    if (res.a == NULL || some_sys_call() == -1) {
        result = -1;
        goto cleanup;
    }

    res.b = malloc(1);
    if (res.b == NULL || some_sys_call() == -1) {
        result = -1;
        goto cleanup;
    }

    res.c = malloc(1);
    if (res.c == NULL) {
        result = -1;
        goto cleanup;
    }

    free(res.a);
    res.a = NULL;
    if (some_sys_call() == -1) {
        result = -1;
        goto cleanup;
    }

cleanup:
    cleanup_resources(&res);
    return result;
}

这种方案适合资源类型多、逻辑复杂的场景，清理逻辑被封装到独立函数中，主代码只需要调用cleanup_resources即可，进一步降低耦合度。

3. 利用RAII思想（模拟） #

C语言本身不支持RAII，但可以通过宏或嵌套函数（部分编译器支持，比如GCC）模拟类似效果，让资源在作用域结束时自动释放。不过这种方案兼容性稍差，适合特定场景：

示例（GCC嵌套函数）：

int main() {
    char *a = malloc(1);
    void cleanup_a() { free(a); }
    if (a == NULL || some_sys_call() == -1) {
        cleanup_a();
        return -1;
    }

    char *b = malloc(1);
    void cleanup_b() { free(b); cleanup_a(); }
    if (b == NULL || some_sys_call() == -1) {
        cleanup_b();
        return -1;
    }

    free(a);
    // 后续只需要清理b和c
    char *c = malloc(1);
    void cleanup_c() { free(c); free(b); }
    if (c == NULL || some_sys_call() == -1) {
        cleanup_c();
        return -1;
    }

    cleanup_c();
    return 0;
}

不过这种方案依赖编译器特性，移植性不如前两种，学校项目中如果允许使用GCC扩展可以尝试，但更推荐前两种标准方案。

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