C语言中实现支持多自定义数据类型的通用栈的惯用方法是什么？

你提到的宏生成专属类型栈的思路，其实是C语言里实现泛型数据结构的标准惯用方式——只是需要调整文件结构来解决可读性和头文件的问题。相比用void*加element_size的通用栈，这种方式类型安全、性能无损耗，完全符合C语言的风格。

优化后的实现步骤 #

1. 拆分模板文件

把栈的结构和实现写成模板，通过宏参数替换元素类型：

stack_template.h（模板头文件，放类型和函数声明）

#ifndef STACK_TEMPLATE_H
#define STACK_TEMPLATE_H

#define CONCAT_PRE(X, Y) X ## _ ## Y
#define CONCAT(X, Y) CONCAT_PRE(X, Y)
#define STACK_TYPE CONCAT(stack, STACK_ELEMENT_TYPE)

// 生成对应类型的栈结构体
typedef struct STACK_TYPE {
    unsigned length;
    unsigned allocated_length;
    STACK_ELEMENT_TYPE *data_pointer;
} STACK_TYPE;

// 声明栈的操作函数
STACK_ELEMENT_TYPE CONCAT(STACK_TYPE, pop)(STACK_TYPE *l);
void CONCAT(STACK_TYPE, push)(STACK_TYPE *l, STACK_ELEMENT_TYPE val);
void CONCAT(STACK_TYPE, init)(STACK_TYPE *l);
void CONCAT(STACK_TYPE, free)(STACK_TYPE *l);

// 清理宏定义，避免污染其他代码
#undef STACK_TYPE
#undef CONCAT
#undef CONCAT_PRE

#endif // STACK_TEMPLATE_H

stack_template.c（模板实现文件，放函数逻辑）

#include <stdlib.h>
#include "stack_template.h"

#define CONCAT_PRE(X, Y) X ## _ ## Y
#define CONCAT(X, Y) CONCAT_PRE(X, Y)
#define STACK_TYPE CONCAT(stack, STACK_ELEMENT_TYPE)

// 弹出元素
STACK_ELEMENT_TYPE CONCAT(STACK_TYPE, pop)(STACK_TYPE *l) {
    if (l->length == 0) abort(); // 下溢处理，可根据需求调整
    l->length--;
    return l->data_pointer[l->length];
}

// 压入元素
void CONCAT(STACK_TYPE, push)(STACK_TYPE *l, STACK_ELEMENT_TYPE val) {
    if (l->length >= l->allocated_length) {
        // 扩容逻辑：初始分配4个元素，之后翻倍
        unsigned new_size = l->allocated_length == 0 ? 4 : l->allocated_length * 2;
        STACK_ELEMENT_TYPE *new_data = realloc(l->data_pointer, new_size * sizeof(STACK_ELEMENT_TYPE));
        if (!new_data) abort(); // 内存分配失败处理，可调整
        l->data_pointer = new_data;
        l->allocated_length = new_size;
    }
    l->data_pointer[l->length] = val;
    l->length++;
}

// 初始化栈
void CONCAT(STACK_TYPE, init)(STACK_TYPE *l) {
    l->length = 0;
    l->allocated_length = 0;
    l->data_pointer = NULL;
}

// 释放栈内存
void CONCAT(STACK_TYPE, free)(STACK_TYPE *l) {
    free(l->data_pointer);
    l->length = 0;
    l->allocated_length = 0;
    l->data_pointer = NULL;
}

#undef STACK_TYPE
#undef CONCAT
#undef CONCAT_PRE

2. 统一对外接口

写一个统一的头文件和实现文件，一次性生成所有需要的类型栈：

stack.h（对外头文件，用户只需包含这个）

#ifndef STACK_H
#define STACK_H

// 提前声明自定义结构体（如果需要）
typedef struct { /* ... */ } my_struct;
typedef struct { /* ... */ } struct_a;
typedef struct { /* ... */ } struct_b;
typedef struct { /* ... */ } struct_c;

// 生成int类型栈
#define STACK_ELEMENT_TYPE int
#include "stack_template.h"
#undef STACK_ELEMENT_TYPE

// 生成my_struct类型栈
#define STACK_ELEMENT_TYPE my_struct
#include "stack_template.h"
#undef STACK_ELEMENT_TYPE

// 生成其他3种自定义结构体的栈
#define STACK_ELEMENT_TYPE struct_a
#include "stack_template.h"
#undef STACK_ELEMENT_TYPE

#define STACK_ELEMENT_TYPE struct_b
#include "stack_template.h"
#undef STACK_ELEMENT_TYPE

#define STACK_ELEMENT_TYPE struct_c
#include "stack_template.h"
#undef STACK_ELEMENT_TYPE

#endif // STACK_H

stack.c（统一实现文件，编译时生成所有类型的栈代码）

// 生成int类型栈的实现
#define STACK_ELEMENT_TYPE int
#include "stack_template.c"
#undef STACK_ELEMENT_TYPE

// 生成my_struct类型栈的实现
#define STACK_ELEMENT_TYPE my_struct
#include "stack_template.c"
#undef STACK_ELEMENT_TYPE

// 生成其他3种类型栈的实现
#define STACK_ELEMENT_TYPE struct_a
#include "stack_template.c"
#undef STACK_ELEMENT_TYPE

#define STACK_ELEMENT_TYPE struct_b
#include "stack_template.c"
#undef STACK_ELEMENT_TYPE

#define STACK_ELEMENT_TYPE struct_c
#include "stack_template.c"
#undef STACK_ELEMENT_TYPE

方案优势 #

• 类型安全：编译时就能检查类型错误，不需要像void*栈那样做强制类型转换，避免运行时bug
• 性能高效：每个类型的栈都是专属实现，没有额外的内存拷贝或类型判断开销
• 维护简单：所有栈的逻辑都在模板里，修改一次就能同步所有类型的实现
• 使用方便：用户只需包含stack.h，就能直接用stack_int_pop、stack_my_struct_push这类清晰命名的函数

对比两种备选方案 #

• void*通用栈：需要传递元素大小，每次操作都要做内存拷贝，不仅代码繁琐，还容易出现类型错误，性能也不如专属栈
• 原始宏方案：优化后解决了可读性和头文件问题，完全符合C语言社区的惯用写法（很多成熟C库，比如Linux内核的部分数据结构，都用这种方式实现泛型）

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