C语言中失败时释放对象的惯用写法？优化对象创建函数

针对你遇到的问题，不用宏的情况下，有几种可读性强、符合C语言惯用风格的写法：

1. 统一清理函数+状态跟踪 #

写一个专门的清理函数，负责按逆序释放所有可能创建的子对象。主函数里只需要跟踪每个子对象的创建状态，失败时调用这个统一清理函数即可，避免重复写释放逻辑。

示例代码：

// 当前编译单元可见的Foo结构体定义
typedef struct {
    IUnknown* com_obj;
    LibraryHandle lib_handle;
    OtherSubObj* sub_obj;
} Foo;

// 统一清理函数，按创建逆序释放资源
static void cleanup_foo_resources(Foo* foo) {
    if (foo->sub_obj) {
        destroy_other_subobj(foo->sub_obj);
        foo->sub_obj = NULL;
    }
    if (foo->lib_handle) {
        close_library(foo->lib_handle);
        foo->lib_handle = NULL;
    }
    if (foo->com_obj) {
        foo->com_obj->lpVtbl->Release(foo->com_obj);
        foo->com_obj = NULL;
    }
}

Foo* create_foo() {
    Foo* foo = malloc(sizeof(Foo));
    if (!foo) return NULL;
    
    // 初始化所有字段为NULL，保证清理函数安全执行
    memset(foo, 0, sizeof(Foo));

    // 创建COM对象
    foo->com_obj = create_com_object();
    if (!foo->com_obj) {
        cleanup_foo_resources(foo);
        free(foo);
        return NULL;
    }

    // 加载库对象
    foo->lib_handle = open_library("some_lib.dll");
    if (!foo->lib_handle) {
        cleanup_foo_resources(foo);
        free(foo);
        return NULL;
    }

    // 创建其他子对象
    foo->sub_obj = create_other_subobj();
    if (!foo->sub_obj) {
        cleanup_foo_resources(foo);
        free(foo);
        return NULL;
    }

    return foo;
}

这种写法的好处是清理逻辑集中维护，后续要修改释放顺序或逻辑，只需要调整cleanup_foo_resources函数，不用在多个失败点重复修改。

2. goto统一清理出口 #

这是C语言里处理资源清理的经典惯用写法，把所有清理逻辑集中到函数末尾的一个标签处，每个创建失败的分支直接跳转到该标签执行清理，避免重复代码。

示例代码：

typedef struct {
    IUnknown* com_obj;
    LibraryHandle lib_handle;
    OtherSubObj* sub_obj;
} Foo;

Foo* create_foo() {
    Foo* foo = NULL;
    IUnknown* com_obj = NULL;
    LibraryHandle lib_handle = NULL;
    OtherSubObj* sub_obj = NULL;

    // 分配Foo对象
    foo = malloc(sizeof(Foo));
    if (!foo) goto cleanup;

    // 创建COM对象
    com_obj = create_com_object();
    if (!com_obj) goto cleanup;

    // 加载库对象
    lib_handle = open_library("some_lib.dll");
    if (!lib_handle) goto cleanup;

    // 创建其他子对象
    sub_obj = create_other_subobj();
    if (!sub_obj) goto cleanup;

    // 所有对象创建成功，赋值给Foo并返回
    foo->com_obj = com_obj;
    foo->lib_handle = lib_handle;
    foo->sub_obj = sub_obj;
    return foo;

cleanup:
    // 按逆序清理资源，未创建的对象指针为NULL，直接判断即可
    if (sub_obj) destroy_other_subobj(sub_obj);
    if (lib_handle) close_library(lib_handle);
    if (com_obj) com_obj->lpVtbl->Release(com_obj);
    if (foo) free(foo);
    return NULL;
}

这种写法的核心是把清理逻辑全部收拢，主流程只关注对象创建，失败就跳转到清理块。很多系统级C代码都会用这种方式，逻辑清晰，可读性强。

3. 封装子对象创建为带清理的辅助函数 #

如果部分子对象存在依赖关系，可以把它们的创建和对应的清理逻辑封装成辅助函数，主函数只需要处理当前层级的对象创建，简化主流程。

示例代码：

// 封装COM对象和库对象的创建与清理
static bool init_com_and_library(IUnknown** out_com, LibraryHandle* out_lib) {
    *out_com = NULL;
    *out_lib = NULL;

    *out_com = create_com_object();
    if (!*out_com) return false;

    *out_lib = open_library("some_lib.dll");
    if (!*out_lib) {
        (*out_com)->lpVtbl->Release(*out_com);
        return false;
    }

    return true;
}

Foo* create_foo() {
    Foo* foo = malloc(sizeof(Foo));
    if (!foo) return NULL;
    memset(foo, 0, sizeof(Foo));

    // 调用辅助函数创建依赖对象
    if (!init_com_and_library(&foo->com_obj, &foo->lib_handle)) {
        free(foo);
        return NULL;
    }

    // 创建剩余子对象
    foo->sub_obj = create_other_subobj();
    if (!foo->sub_obj) {
        cleanup_foo_resources(foo); // 复用统一清理函数
        free(foo);
        return NULL;
    }

    return foo;
}

这种方式可以把复杂的依赖创建逻辑隔离，主函数的流程更简洁，也减少了冗余代码。

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