如何在C语言中存储运行时确定类型的数据并高效转为浮点值

我需要存储一些仅在运行时才知晓类型的数据，要求不浪费内存，且所有数据均可读取为float值。在C++中我会采用如下实现方式：

struct IA { virtual float value(int index) = 0; }; 
template<class T> struct A : public IA { 
A(T* bytes, uint32_t size) { values.resize(size); memcpy(values.data(), bytes, size*sizeof(T)); } 
float value(int index) override { return static_cast<float>(values[index]); } 
std::vector<T> values; 
}; 
int main() { uint16_t bytes[] = {1, 2, 3, 4, 5 }; IA *a = new A<uint16_t>(bytes, 5); float value = a->value(0); delete a; }

请问如何用C语言实现类似功能？我曾考虑使用uint8_t数组存储数据，同时记录数据位数与符号属性，每次读取时通过switch分支进行类型转换，但这种方式在数据量大、读取频繁时性能开销较高，并且我希望能够无需特殊判断即可传递该数据结构。

在C里没有C那样的类和虚函数机制，但我们可以用函数指针来模拟这种多态行为——既不浪费内存，又能像你原来的C代码那样，用统一的接口处理不同类型的数据，还避免了switch分支带来的性能开销。下面是具体的实现方案：

核心思路 #

我们定义一个统一的接口结构体，里面包含两个函数指针：

• 一个用于获取指定索引的float值
• 一个用于销毁整个数据结构（释放内存）
  同时用一个void*指针指向具体类型的存储数据。这样所有不同类型的实例都可以通过这个统一的接口结构体指针传递和调用，完全不需要额外的类型判断。

完整实现代码 #

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// 统一的动态数据接口结构体，模拟C++的抽象基类
typedef struct DynamicData DynamicData;
struct DynamicData {
    // 获取指定索引的float值
    float (*value)(const DynamicData* data, int index);
    // 销毁数据结构，释放所有内存
    void (*destroy)(DynamicData* data);
    // 指向具体类型的存储数据（内部使用，外部无需关心）
    void* storage;
};

// ------------------------------
// uint16_t 类型的具体实现
// ------------------------------
typedef struct {
    uint16_t* values;
    uint32_t size;
} UInt16Data;

static float uint16_value(const DynamicData* data, int index) {
    UInt16Data* storage = (UInt16Data*)data->storage;
    // 简单的越界检查，你可以根据需求调整错误处理逻辑
    if (index < 0 || index >= (int)storage->size) {
        return 0.0f;
    }
    return (float)storage->values[index];
}

static void uint16_destroy(DynamicData* data) {
    UInt16Data* storage = (UInt16Data*)data->storage;
    free(storage->values);
    free(storage);
    free(data);
}

// 创建uint16_t类型的动态数据实例
DynamicData* create_uint16_data(const uint16_t* bytes, uint32_t size) {
    DynamicData* data = (DynamicData*)malloc(sizeof(DynamicData));
    if (!data) return NULL;

    UInt16Data* storage = (UInt16Data*)malloc(sizeof(UInt16Data));
    if (!storage) {
        free(data);
        return NULL;
    }

    storage->values = (uint16_t*)malloc(size * sizeof(uint16_t));
    if (!storage->values) {
        free(storage);
        free(data);
        return NULL;
    }

    memcpy(storage->values, bytes, size * sizeof(uint16_t));
    storage->size = size;

    // 绑定对应的函数实现
    data->value = uint16_value;
    data->destroy = uint16_destroy;
    data->storage = storage;

    return data;
}

// ------------------------------
// uint8_t 类型的具体实现（可扩展其他类型，比如int32_t等）
// ------------------------------
typedef struct {
    uint8_t* values;
    uint32_t size;
} UInt8Data;

static float uint8_value(const DynamicData* data, int index) {
    UInt8Data* storage = (UInt8Data*)data->storage;
    if (index < 0 || index >= (int)storage->size) {
        return 0.0f;
    }
    return (float)storage->values[index];
}

static void uint8_destroy(DynamicData* data) {
    UInt8Data* storage = (UInt8Data*)data->storage;
    free(storage->values);
    free(storage);
    free(data);
}

DynamicData* create_uint8_data(const uint8_t* bytes, uint32_t size) {
    DynamicData* data = (DynamicData*)malloc(sizeof(DynamicData));
    if (!data) return NULL;

    UInt8Data* storage = (UInt8Data*)malloc(sizeof(UInt8Data));
    if (!storage) {
        free(data);
        return NULL;
    }

    storage->values = (uint8_t*)malloc(size * sizeof(uint8_t));
    if (!storage->values) {
        free(storage);
        free(data);
        return NULL;
    }

    memcpy(storage->values, bytes, size * sizeof(uint8_t));
    storage->size = size;

    data->value = uint8_value;
    data->destroy = uint8_destroy;
    data->storage = storage;

    return data;
}

// ------------------------------
// 测试示例
// ------------------------------
int main() {
    // 测试uint16_t类型
    uint16_t bytes[] = {1, 2, 3, 4, 5};
    DynamicData* a = create_uint16_data(bytes, 5);
    if (a) {
        float value = a->value(a, 0);
        printf("uint16_t value at index 0: %.2f\n", value);
        a->destroy(a);
    }

    // 测试uint8_t类型
    uint8_t bytes2[] = {10, 20, 30};
    DynamicData* b = create_uint8_data(bytes2, 3);
    if (b) {
        float value2 = b->value(b, 1);
        printf("uint8_t value at index 1: %.2f\n", value2);
        b->destroy(b);
    }

    return 0;
}

方案优势 #

1. 内存高效：每种类型都用对应大小的数组存储，没有额外的内存浪费（接口结构体本身的开销可以忽略）。
2. 性能优异：读取数据时直接调用对应类型的转换函数，没有switch分支的判断开销，和C++虚函数的调用性能几乎一致。
3. 接口统一：所有类型都通过DynamicData*指针传递，调用时只需要使用统一的value和destroy方法，完全不需要做类型判断，和你原来的C++多态用法逻辑一致。
4. 可扩展性强：如果需要支持新的类型（比如int32_t、float本身），只需要添加对应的存储结构体、value函数、destroy函数和create函数即可，不需要修改现有代码。

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