C语言作业优化咨询：8位总线下float数据拆分传输合并方案

我有一项C语言课程作业，场景是两个设备间的数据传输：需要传输的是4字节的float类型数据，但数据总线仅为8位，因此需要将float拆分为4个unsigned char进行传输，再重新合并，最终要得到数值7.7。

老师提供的代码框架如下：

transmision(unsigned char c0, unsigned char c1, unsigned char c2, unsigned char c3)
{
float f;
......
//change: 4 bajty c0,c1,c2,c3 to float}
.....
printf ("after transmision f=%f\n",f)
// Should be printed 7.7
}

我自己实现的方案如下：

#include <stdio.h>

typedef union {
    float f;
    unsigned char bajty[4];
} FloatUnion;

void transmisja(unsigned char c0, unsigned char c1, unsigned char c2, unsigned char c3) {
    FloatUnion data;
    // 拼接收到的字节为float
    data.bajty[0] = c0;
    data.bajty[1] = c1;
    data.bajty[2] = c2;
    data.bajty[3] = c3;
    // 输出得到的数值
    printf("po transmisji f=%f\n", data.f);
}

int main(void) {
    FloatUnion data;
    // 设置float值为7.7
    data.f = 7.7;
    
    // "传输"——依次发送四个字节
    transmisja(data.bajty[0], data.bajty[1], data.bajty[2], data.bajty[3]);
    
    return 0;
}

请问该实现是否有更优的改进方案？

你的实现思路没问题，但可以从跨平台兼容性、代码规范性和复用性这几个维度优化：

1. 明确字节序（大小端）处理 #

当前代码依赖系统默认字节序，不同设备的字节序可能不同（比如x86是小端，部分嵌入式设备是大端），直接按数组顺序拼接会导致跨设备传输数据错误。建议统一传输的字节序（比如通用的大端）：

// 发送时按大端拆分float
void split_float(float val, unsigned char buf[4]) {
    unsigned char *raw_bytes = (unsigned char*)&val;
    // 大端格式：最高字节存buf[0]
    buf[0] = raw_bytes[3];
    buf[1] = raw_bytes[2];
    buf[2] = raw_bytes[1];
    buf[3] = raw_bytes[0];
}

// 接收时按大端合并为float
float merge_to_float(unsigned char buf[4]) {
    float val;
    unsigned char *raw_bytes = (unsigned char*)&val;
    // 按大端还原内存
    raw_bytes[3] = buf[0];
    raw_bytes[2] = buf[1];
    raw_bytes[1] = buf[2];
    raw_bytes[0] = buf[3];
    return val;
}

这样不管两端设备原生字节序是什么，都能保证传输后的数据正确。

2. 规避union的未定义行为 #

C标准中，读取union中未被最后写入的成员属于未定义行为（虽然多数编译器支持，但不符合规范）。改用指针直接操作内存更严谨：

void transmisja(unsigned char c0, unsigned char c1, unsigned char c2, unsigned char c3) {
    float f;
    unsigned char *f_bytes = (unsigned char*)&f;
    // 按约定字节序赋值
    f_bytes[3] = c0;
    f_bytes[2] = c1;
    f_bytes[1] = c2;
    f_bytes[0] = c3;
    printf("传输后 f=%f\n", f);
}

3. 模块化拆分逻辑 #

把拆分、合并的逻辑封装成独立函数，而非散落在main和transmisja中，方便后续复用和维护：

// 拆分float为字节数组，支持指定字节序
void float_to_bytes(float f, unsigned char bytes[4], int use_big_endian) {
    unsigned char *raw = (unsigned char*)&f;
    if (use_big_endian) {
        bytes[0] = raw[3];
        bytes[1] = raw[2];
        bytes[2] = raw[1];
        bytes[3] = raw[0];
    } else {
        bytes[0] = raw[0];
        bytes[1] = raw[1];
        bytes[2] = raw[2];
        bytes[3] = raw[3];
    }
}

// 从字节数组合并为float，支持指定字节序
float bytes_to_float(unsigned char bytes[4], int use_big_endian) {
    float f;
    unsigned char *raw = (unsigned char*)&f;
    if (use_big_endian) {
        raw[3] = bytes[0];
        raw[2] = bytes[1];
        raw[1] = bytes[2];
        raw[0] = bytes[3];
    } else {
        raw[0] = bytes[0];
        raw[1] = bytes[1];
        raw[2] = bytes[2];
        raw[3] = bytes[3];
    }
    return f;
}

之后main和transmisja直接调用这些函数即可，逻辑更清晰。

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