如何在C语言中实现未知类型、已知大小的数组类型转换？

首先明确：C语言无法仅通过类型大小在运行时动态构造指针类型，因为C的类型系统是静态编译的，指针类型必须在编译期确定，运行时的变量值（比如elsize_a）无法用来推导或生成类型。但我们可以通过函数指针分发的方式，实现无冗余分支的通用数组转换，同时保证效率。

核心思路 #

利用文件头提供的编码类型（而非仅类型大小），将对应的转换逻辑封装为独立函数，通过映射表匹配并调用对应函数，避免冗余的if-else分支。每个转换函数都是类型明确的，编译器可充分优化，效率与手写类型转换循环一致。

步骤1：定义转换函数原型与具体实现 #

先定义统一的转换函数接口，再针对需要的类型对实现具体逻辑：

#include <stddef.h>
#include <stdlib.h>

// 通用转换函数原型
typedef void (*ConvertFunc)(void* dst, const void* src, size_t count);

// short -> int 转换
void convert_short_to_int(void* dst, const void* src, size_t count) {
    int* d = (int*)dst;
    const short* s = (const short*)src;
    for (size_t i = 0; i < count; ++i) {
        d[i] = (int)s[i];
    }
}

// float -> int 转换（假设float无小数部分）
void convert_float_to_int(void* dst, const void* src, size_t count) {
    int* d = (int*)dst;
    const float* s = (const float*)src;
    for (size_t i = 0; i < count; ++i) {
        d[i] = (int)s[i];
    }
}

// 可扩展其他类型对的转换函数，比如int->float、int->short等

步骤2：定义编码类型枚举与映射表 #

用枚举表示文件头的编码类型，再创建类型对到转换函数的映射表：

// 编码类型枚举，与文件头标注的类型对应
typedef enum {
    ENCODING_SHORT,
    ENCODING_INT,
    ENCODING_FLOAT,
    // 根据需求添加更多类型
} EncodingType;

// 类型对-转换函数映射结构体
typedef struct {
    EncodingType dst_type;
    EncodingType src_type;
    ConvertFunc func;
} ConvertMap;

// 根据目标类型与源类型查找对应转换函数
ConvertFunc get_convert_func(EncodingType dst_type, EncodingType src_type) {
    static const ConvertMap map[] = {
        {ENCODING_INT, ENCODING_SHORT, convert_short_to_int},
        {ENCODING_INT, ENCODING_FLOAT, convert_float_to_int},
        // 添加其他需要的类型组合
    };
    const size_t map_len = sizeof(map) / sizeof(map[0]);
    
    for (size_t i = 0; i < map_len; ++i) {
        if (map[i].dst_type == dst_type && map[i].src_type == src_type) {
            return map[i].func;
        }
    }
    return NULL; // 无匹配转换函数，需处理错误
}

步骤3：实现通用populate函数 #

修改原populate函数，添加元素数量参数与编码类型参数，通过映射表调用对应转换函数：

void populate(void* arr_a, void* arr_b, EncodingType dst_type, EncodingType src_type, size_t count) {
    ConvertFunc convert = get_convert_func(dst_type, src_type);
    if (!convert) {
        // 错误处理：比如断言、返回错误码或日志
        return;
    }
    convert(arr_a, arr_b, count);
}

步骤4：使用示例 #

从文件读取二进制数据后，根据文件头的编码类型调用populate：

// 模拟从文件获取二进制数据与编码类型
void* some_binary_data_from_a_file() {
    // 实际场景中从文件读取
    return calloc(10, sizeof(short));
}

EncodingType get_encoding_from_file_header(void* bin) {
    // 实际场景中解析文件头获取编码类型
    return ENCODING_SHORT;
}

int main() {
    const size_t n = 10;
    int* an_array = calloc(n, sizeof(int));
    void* bin = some_binary_data_from_a_file();
    EncodingType src_encoding = get_encoding_from_file_header(bin);

    // 调用通用转换函数
    populate(an_array, bin, ENCODING_INT, src_encoding, n);

    // 后续处理...
    free(an_array);
    free(bin);
    return 0;
}

替代方案：编译期泛型宏（适用于编译期确定类型的场景） #

如果类型在编译期即可确定，可使用宏模拟泛型，代码更简洁：

#define POPULATE(dst, src, dst_type, src_type, count) do { \
    dst_type* d = (dst_type*)dst; \
    const src_type* s = (const src_type*)src; \
    for (size_t i = 0; i < count; ++i) { \
        d[i] = (dst_type)s[i]; \
    } \
} while(0)

// 使用示例
POPULATE(an_array, bin, int, short, n);

但该方案仅适用于编译期已知类型的场景，无法处理运行时动态确定类型的需求。

关键注意事项 #

1. 必须传递元素数量：原问题中缺少元素数量参数，无法完成循环转换，必须补充。
2. 不能仅依赖类型大小：不同算术类型可能大小相同（如32位系统中int与float均为4字节），必须用文件头的编码类型标识来区分。
3. 类型安全与错误处理：转换前需确保类型转换合法（如用户提到的float无小数部分），无匹配转换函数时需添加错误处理逻辑。

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