如何优雅处理malloc内存分配失败？多指针场景最佳实践

问题背景 #

需要多次调用malloc（或类似动态分配函数），要求任意一次分配失败时，释放已成功分配的内存并提前返回。追求易读、易写、简洁的代码，而非性能优化。实际场景是实现树结构的创建函数，其中需要分配tree_t结构体、数据缓冲区、链表对象三类资源。

已尝试的方案 #

方案1：分步分配+逐个清理 #

每次分配后检查失败，失败时手动释放之前分配的资源：

void test(void) {
   int *a, *b, *c;
   
   a = malloc(sizeof(*a));
   if (a == NULL)
      return;

   b = malloc(sizeof(*b));
   if (b == NULL) {
      free(a);   /* 因为`a`已完成malloc分配。 */
      return;
   }

   c = malloc(sizeof(*c));
   if (c == NULL) {
      free(a);   // 因为`a`和`b`已
      free(b);   // 完成malloc分配。
      return;
   }
}

缺点：资源越多，失败时需要写的free语句越多，代码冗余且容易遗漏。

方案2：全部分配后统一检查清理 #

先完成所有分配，再统一检查是否有失败，失败时释放所有指针（利用free(NULL)安全的特性）：

a = malloc(sizeof(*a));
b = malloc(sizeof(*b));
c = malloc(sizeof(*c));

if (a == NULL || b == NULL || c == NULL) {
   free(a);   // 我了解free空指针是安全的
   free(b);
   free(c);
   return;
}

缺点：指针数量增多时，检查和清理代码会变得杂乱，且会做不必要的分配（比如a失败后仍会分配b和c）。

方案3：一次性分配整块内存 #

将所有需要的内存一次性分配，再拆分给各个指针：

void *container;

container = malloc(sizeof(int) * 3);
if (container == NULL)
   return;

a = getaddr(container, 0);
b = getaddr(container, 1);
c = getaddr(container, 2);

// 定义getaddr
static inline int *getaddr(void *base, int index) {
   return base + (sizeof(int) * index);
}

缺点：仅适用于同类型内存的分配，对于不同类型（比如结构体、链表、数据缓冲区）的场景，拆分和管理会很繁琐，且不符合抽象数据类型的封装原则。

方案4：uintptr_t转换技巧 #

将指针转为uintptr_t来批量处理，但依赖NULL == 0的前提，可移植性存疑，不推荐。

推荐的优雅方案 #

针对你的树结构创建场景，推荐两种实用方案：

方案A：使用goto统一清理 #

利用goto跳转到统一的清理代码块，避免重复编写free逻辑，代码简洁且易维护：

extern tree_t *tree_plant(void *data, size_t data_size) {
   if (data == NULL || data_size == 0)
      return NULL;
   
   tree_t *sapling = NULL;
   void *tree_data = NULL;
   list_t *tree_children = NULL;
   
   // 分步分配资源
   sapling = malloc(sizeof(tree_t));
   if (sapling == NULL) goto cleanup;
   
   tree_data = malloc(data_size);
   if (tree_data == NULL) goto cleanup;
   
   tree_children = list_create();
   if (tree_children == NULL) goto cleanup;
   
   // 初始化字段
   sapling->parent = NULL;
   sapling->children = tree_children;
   sapling->data = tree_data;
   sapling->data_size = data_size;
   memcpy(sapling->data, data, data_size);
   
   return sapling;

cleanup:
   // 统一清理已分配的资源，free空指针安全
   free(sapling);
   free(tree_data);
   if (tree_children != NULL) {
       // 如果list有自己的销毁函数，这里应该调用list_destroy(tree_children)
       // 比如假设list_destroy会free链表结构体
       list_destroy(tree_children);
   }
   return NULL;
}

优点：所有清理逻辑集中在一处，新增资源时只需在cleanup块添加对应释放语句，代码结构清晰，不会遗漏。

方案B：封装资源清理函数 #

如果不喜欢goto，可以封装一个清理函数，将已分配的资源传入统一清理：

static void cleanup_tree_resources(tree_t *sapling, void *tree_data, list_t *tree_children) {
   free(sapling);
   free(tree_data);
   if (tree_children != NULL) {
       list_destroy(tree_children);
   }
}

extern tree_t *tree_plant(void *data, size_t data_size) {
   if (data == NULL || data_size == 0)
      return NULL;
   
   tree_t *sapling = NULL;
   void *tree_data = NULL;
   list_t *tree_children = NULL;
   
   sapling = malloc(sizeof(tree_t));
   if (sapling == NULL) {
       cleanup_tree_resources(sapling, tree_data, tree_children);
       return NULL;
   }
   
   tree_data = malloc(data_size);
   if (tree_data == NULL) {
       cleanup_tree_resources(sapling, tree_data, tree_children);
       return NULL;
   }
   
   tree_children = list_create();
   if (tree_children == NULL) {
       cleanup_tree_resources(sapling, tree_data, tree_children);
       return NULL;
   }
   
   // 初始化字段
   sapling->parent = NULL;
   sapling->children = tree_children;
   sapling->data = tree_data;
   sapling->data_size = data_size;
   memcpy(sapling->data, data, data_size);
   
   return sapling;
}

优点：清理逻辑封装后，主函数代码更整洁，适合资源类型固定的场景。需要注意的是，若链表等资源有专属的销毁函数（比如list_destroy），一定要在清理函数中调用，而非直接free。

额外建议 #

• 对于自定义的抽象数据类型（比如你的list_t），一定要提供对应的销毁函数（list_destroy），内部负责释放链表的所有资源，这样上层代码无需关心链表的内存细节，降低出错概率。
• 始终利用free(NULL)安全的特性，无需在清理前检查指针是否为NULL（除了需要调用专属销毁函数的情况，因为销毁函数可能不接受NULL）。

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