如何在C语言中将类型作为函数参数实现泛型数组操作？

当然能实现啦！C语言虽然没有像C++那样的原生泛型支持，但咱们可以通过宏、函数指针回调或者C11引入的_Generic关键字来模拟泛型行为，完美满足你接收void**数组、传入元素类型并初始化指定位置的需求。下面给你几个实际的实现例子，每种思路都有各自的适用场景：

方法1：用宏生成类型专属的初始化函数 #

宏是C里处理类型的老伙计了，因为它在编译前的预处理阶段就能直接操作类型名称。我们可以写一个宏模板，传入类型就能自动生成对应的初始化函数：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 宏模板：传入类型，生成该类型的初始化函数
#define MAKE_INIT_FUNC(type) \
void init_##type(void** arr, int index) { \
    // 分配对应类型的内存块
    arr[index] = malloc(sizeof(type)); \
    if (!arr[index]) { \
        perror("内存分配失败"); \
        return; \
    } \
    // 随机初始化：这里针对数值类型，字符串等复杂类型可以调整逻辑
    *((type*)arr[index]) = (type)(rand() % 100); \
}

// 生成int、float、double类型的初始化函数
MAKE_INIT_FUNC(int)
MAKE_INIT_FUNC(float)
MAKE_INIT_FUNC(double)

int main() {
    srand(time(NULL)); // 初始化随机数种子
    // 创建一个容量为5的void**数组
    void** arr = malloc(5 * sizeof(void*));
    if (!arr) {
        perror("数组内存分配失败");
        return 1;
    }

    // 初始化索引0为int类型，索引1为float类型
    init_int(arr, 0);
    init_float(arr, 1);

    // 打印验证结果
    printf("arr[0] (int): %d\n", *((int*)arr[0]));
    printf("arr[1] (float): %.2f\n", *((float*)arr[1]));

    // 记得释放内存！
    free(arr[0]);
    free(arr[1]);
    free(arr);
    return 0;
}

为啥这么做？ #

• 宏展开后会生成像init_int、init_float这样的类型专属函数，编译时就能检查类型匹配问题，安全性很高。
• 缺点是每新增一个类型，就得用宏生成对应的函数，适合类型不多的场景。

方法2：用函数指针传递初始化逻辑（灵活度拉满） #

如果不想为每个类型单独生成函数，可以把类型相关的初始化逻辑封装成回调函数，主函数只负责分配内存和调用回调，完全不关心具体类型：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 定义回调函数类型：负责初始化一块内存
typedef void (*InitHandler)(void*);

// 通用初始化函数：接收数组、元素大小、索引、初始化回调
void generic_init(void** arr, size_t elem_size, int index, InitHandler handler) {
    arr[index] = malloc(elem_size);
    if (!arr[index]) {
        perror("内存分配失败");
        return;
    }
    // 交给回调函数去初始化这块内存
    handler(arr[index]);
}

// int类型的初始化回调
void init_int(void* ptr) {
    *((int*)ptr) = rand() % 100;
}

// float类型的初始化回调
void init_float(void* ptr) {
    *((float*)ptr) = (float)(rand() % 100) / 10.0f;
}

int main() {
    srand(time(NULL));
    void** arr = malloc(5 * sizeof(void*));
    if (!arr) {
        perror("数组内存分配失败");
        return 1;
    }

    // 初始化索引0为int：传入int的大小和对应的回调
    generic_init(arr, sizeof(int), 0, init_int);
    // 初始化索引1为float
    generic_init(arr, sizeof(float), 1, init_float);

    printf("arr[0] (int): %d\n", *((int*)arr[0]));
    printf("arr[1] (float): %.2f\n", *((float*)arr[1]));

    free(arr[0]);
    free(arr[1]);
    free(arr);
    return 0;
}

优势在哪？ #

• generic_init是真正的泛型函数，完全和类型解耦，新增类型只需要写对应的回调函数就行，不用动主逻辑，非常灵活。
• 适合类型较多或者需要动态切换初始化逻辑的场景。

方法3：用C11的_Generic实现统一接口（最像原生泛型） #

如果你的编译器支持C11标准，可以用_Generic关键字实现一个统一的调用接口，自动根据你指定的类型选择对应的初始化函数，看起来就像原生泛型一样：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 不同类型的初始化实现
void init_int(void** arr, int index) {
    arr[index] = malloc(sizeof(int));
    *((int*)arr[index]) = rand() % 100;
}

void init_float(void** arr, int index) {
    arr[index] = malloc(sizeof(float));
    *((float*)arr[index]) = (float)(rand() % 100) / 10.0f;
}

// 统一泛型接口：用_Generic根据类型匹配对应的函数
#define generic_init(arr, index, type) _Generic((type), \
    int: init_int, \
    float: init_float \
)(arr, index)

int main() {
    srand(time(NULL));
    void** arr = malloc(5 * sizeof(void*));
    if (!arr) {
        perror("数组内存分配失败");
        return 1;
    }

    // 调用统一接口，直接指定类型就行
    generic_init(arr, 0, int);
    generic_init(arr, 1, float);

    printf("arr[0] (int): %d\n", *((int*)arr[0]));
    printf("arr[1] (float): %.2f\n", *((float*)arr[1]));

    free(arr[0]);
    free(arr[1]);
    free(arr);
    return 0;
}

说明： #

• _Generic是C11新增的类型匹配关键字，它会根据你传入的type参数的类型，自动选择对应的初始化函数。
• 这种方式调用起来最简洁，体验最接近原生泛型，但要注意编译器版本（比如GCC 4.9+、Clang 3.1+才支持）。

需要提醒的是，C语言毕竟是静态类型语言，运行时没有类型信息，所以所有泛型模拟都绕不开类型转换或者手动传递类型相关信息（比如大小、回调），但上面的几种方案都能很好地满足你的需求，根据你的实际场景选就行～

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