动态分配变量错误检查的最优结构化实现方案探讨

我正在开发Python C扩展项目，涉及队列、线程相关的多个动态分配结构体。当前代码能正常运行，但每次动态分配后的错误检查和资源清理逻辑重复，大幅降低了代码的流程可读性。希望在保留准确错误信息的前提下优化代码结构，目前已考虑用goto语句优化，想了解其他更优方案。

原代码示例：

#include <Python.h>
#include <stdlib.h>

typedef struct Queue{
   void *data;
} Queue;
typedef struct Control{
   void *data;
} Control;
typedef struct Logging{
   void *data;
} Logging;
typedef struct Args{
   Queue *q;
   Control *c;
   Logging *l;
   void *data;
} Args;

void cleanupQueue(Queue *q);
void cleanupControl(Control *c);
void cleanupLogging(Logging *l);
void cleanupArgs(Args *a);
static PyObject *pycalledfunction(){
  Queue *queue = (Queue *) malloc(sizeof(Queue));
  if(!queue){
    PyErr_SetString(type, message);
    return NULL;
  }
  // initialize queue and fill
  
  Control *control = (Control *) malloc(sizeof(Control));
  if(!control){
    cleanupQueue(queue);
    PyErr_SetString(type, message);
    return NULL;
  }
  // initialize control
  
  Logging *logging = (Logging *) malloc(sizeof(Logging));
  if(!logging){
    cleanupControl(control);
    cleanupQueue(queue);
    PyErr_SetString(type, message);
    return NULL;
  }
  // initialize logging
  
  Args *args = (Args *) malloc(sizeof(Args));
  if(!args){ // 原代码此处笔误，修正为!args
    cleanupLogging(logging);
    cleanupControl(control);
    cleanupQueue(queue);
    PyErr_SetString(type, message);
    return NULL;
  }
  // initialize and fill args with the other structs
  
  // Note: I guess I could check if they all exist before doing work with them here but I was unsure if that is a good practice since I am loading them into the args and am keen on getting the correct error message.
  
  // bunch of work here
  
  cleanupQueue(queue);
  cleanupControl(control);
  cleanupLogging(logging);
  cleanupArgs(args);
  return obj;
}

方案1：goto统一错误处理（工业界常用） #

这是C语言中处理多资源分配错误最成熟的方案，将所有清理逻辑集中到函数末尾的统一标签处，避免重复编写清理代码，同时保留精准的错误信息设置。这种方式被Linux内核、PostgreSQL等大型项目广泛采用，属于结构化编程的合理用法，并非“不良实践”。

修改后的代码示例：

static PyObject *pycalledfunction(){
  Queue *queue = NULL;
  Control *control = NULL;
  Logging *logging = NULL;
  Args *args = NULL;
  PyObject *result = NULL;

  queue = (Queue *) malloc(sizeof(Queue));
  if(!queue){
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Queue");
    goto cleanup;
  }
  // initialize queue and fill

  control = (Control *) malloc(sizeof(Control));
  if(!control){
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Control");
    goto cleanup;
  }
  // initialize control

  logging = (Logging *) malloc(sizeof(Logging));
  if(!logging){
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Logging");
    goto cleanup;
  }
  // initialize logging

  args = (Args *) malloc(sizeof(Args));
  if(!args){
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Args");
    goto cleanup;
  }
  // initialize and fill args with the other structs

  // bunch of work here
  // 假设此处成功生成了result对象
  result = Py_BuildValue("i", 0);

cleanup:
  // 清理函数需要能接收NULL并安全处理（比如先判断指针非空再操作）
  cleanupQueue(queue);
  cleanupControl(control);
  cleanupLogging(logging);
  cleanupArgs(args);
  return result;
}

注意：需确保cleanupXxx函数能安全处理NULL指针（比如开头加if (!ptr) return;），避免未初始化指针传入导致的崩溃。

方案2：封装分配与初始化函数 #

将每个结构体的内存分配、初始化、错误处理封装成独立函数，函数内部负责分配失败时的资源清理（如果有前置依赖），返回NULL或错误码，主函数逻辑会更简洁。

示例：

// 封装Queue的分配与初始化
Queue* createQueue() {
  Queue *q = (Queue *) malloc(sizeof(Queue));
  if (!q) {
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Queue");
    return NULL;
  }
  // 初始化Queue逻辑
  return q;
}

// 封装Control的分配与初始化
Control* createControl() {
  Control *c = (Control *) malloc(sizeof(Control));
  if (!c) {
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Control");
    return NULL;
  }
  // 初始化Control逻辑
  return c;
}

// 封装Args的分配与初始化，依赖已创建的Queue/Control/Logging
Args* createArgs(Queue *q, Control *c, Logging *l) {
  Args *a = (Args *) malloc(sizeof(Args));
  if (!a) {
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Args");
    cleanupLogging(l);
    cleanupControl(c);
    cleanupQueue(q);
    return NULL;
  }
  a->q = q;
  a->c = c;
  a->l = l;
  // 其他初始化逻辑
  return a;
}

// 主函数简化为：
static PyObject *pycalledfunction(){
  Queue *queue = createQueue();
  if (!queue) return NULL;

  Control *control = createControl();
  if (!control) {
    cleanupQueue(queue);
    return NULL;
  }

  Logging *logging = createLogging(); // 需自行实现createLogging
  if (!logging) {
    cleanupControl(control);
    cleanupQueue(queue);
    return NULL;
  }

  Args *args = createArgs(queue, control, logging);
  if (!args) return NULL;

  // bunch of work here

  cleanupArgs(args); // 若cleanupArgs内部已处理依赖资源的清理，主函数无需单独调用cleanupQueue等
  return obj;
}

这种方式把每个结构体的创建逻辑解耦，主函数更聚焦业务流程，但如果依赖链复杂，仍需在封装函数中处理前置资源的清理。

方案3：统一资源管理结构体 #

创建一个包含所有动态分配资源的“容器”结构体，统一管理所有资源，清理时只需调用一个总清理函数，错误时直接清理整个容器。

示例：

typedef struct Resources {
  Queue *queue;
  Control *control;
  Logging *logging;
  Args *args;
} Resources;

void cleanupResources(Resources *res) {
  if (!res) return;
  cleanupArgs(res->args);
  cleanupLogging(res->logging);
  cleanupControl(res->control);
  cleanupQueue(res->queue);
  free(res);
}

static PyObject *pycalledfunction(){
  Resources *res = (Resources *) malloc(sizeof(Resources));
  if (!res) {
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate resources container");
    return NULL;
  }
  memset(res, 0, sizeof(Resources)); // 初始化所有指针为NULL

  res->queue = (Queue *) malloc(sizeof(Queue));
  if (!res->queue) {
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Queue");
    cleanupResources(res);
    return NULL;
  }
  // initialize queue

  res->control = (Control *) malloc(sizeof(Control));
  if (!res->control) {
    PyErr_SetString(PyExc_MemoryError, "Failed to allocate Control");
    cleanupResources(res);
    return NULL;
  }
  // initialize control

  // 后续分配逻辑类似...

  // bunch of work here

  cleanupResources(res);
  return obj;
}

这种方式把所有资源打包，错误时只需调用一次cleanupResources，无需逐个清理，但需要额外维护这个容器结构体，适合资源数量较多的场景。

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