如何使用流序列化复杂POD类型，生成串口传输所需的二进制数据包？

原有方案的潜在问题 #

你当前用联合体+结构体的实现依赖编译器的内存对齐规则，不同架构、编译选项可能导致结构体中间被插入填充字节，且无法主动控制端序（大小端），跨设备串口传输很容易出现解析错误。用流实现二进制序列化可以很好解决这两个核心问题，同时满足紧凑无填充、端序可控的要求。

二进制序列化流实现方案 #

你可以自己封装轻量的二进制流类，底层可以对接std::ostream或者固定大小的字节缓冲区，按协议顺序写入字段即可，完全不需要依赖结构体布局。

基础实现代码 #

#include <cstdint>
#include <ostream>
#include <array>
#include <algorithm>

// 端序判断，也可以手动指定传输用的统一端序（串口/网络通用默认大端）
constexpr bool is_little_endian = __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__;

// 二进制写入流封装
class BinaryOStream {
private:
    std::ostream& os;
public:
    explicit BinaryOStream(std::ostream& out) : os(out) {}

    // uint8_t 序列化
    BinaryOStream& operator<<(uint8_t val) {
        os.write(reinterpret_cast<const char*>(&val), 1);
        return *this;
    }

    // uint16_t 序列化，自动转大端
    BinaryOStream& operator<<(uint16_t val) {
        if constexpr (is_little_endian) {
            uint8_t bytes[2] = {
                static_cast<uint8_t>((val >> 8) & 0xFF),
                static_cast<uint8_t>(val & 0xFF)
            };
            os.write(reinterpret_cast<const char*>(bytes), 2);
        } else {
            os.write(reinterpret_cast<const char*>(&val), 2);
        }
        return *this;
    }

    // uint32_t 序列化，自动转大端
    BinaryOStream& operator<<(uint32_t val) {
        if constexpr (is_little_endian) {
            uint8_t bytes[4] = {
                static_cast<uint8_t>((val >> 24) & 0xFF),
                static_cast<uint8_t>((val >> 16) & 0xFF),
                static_cast<uint8_t>((val >> 8) & 0xFF),
                static_cast<uint8_t>(val & 0xFF)
            };
            os.write(reinterpret_cast<const char*>(bytes), 4);
        } else {
            os.write(reinterpret_cast<const char*>(&val), 4);
        }
        return *this;
    }

    // 可按需扩展int系列、float、double等类型的重载
};

使用示例 #

和你原来的逻辑兼容，只需要按协议顺序写入字段即可：

#include <sstream>
#include <unistd.h>

int main() {
    // 底层用stringstream做缓冲区，也可以直接绑定串口文件对应的ostream
    std::stringstream ss;
    BinaryOStream bstream(ss);

    // 按顺序写入字段，自动紧凑打包
    uint32_t d1 = 42;
    uint8_t d2 = 17;
    bstream << d1 << d2;

    // 拿到序列化后的二进制数据直接发串口
    std::string buf = ss.str();
    write(fd, buf.data(), buf.size());

    return 0;
}

复杂POD类型扩展 #

如果是嵌套的复杂结构体，只需要重载对应的operator<<即可直接序列化：

// 自定义复杂POD包结构
struct ComplexPacket {
    uint16_t header;
    uint32_t payload_len;
    uint8_t cmd;
    uint32_t data[4];
};

// 重载序列化算子
BinaryOStream& operator<<(BinaryOStream& bs, const ComplexPacket& pkt) {
    bs << pkt.header << pkt.payload_len << pkt.cmd;
    for (auto val : pkt.data) bs << val;
    return bs;
}

// 之后可以直接写入整个结构体
// ComplexPacket pkt{...};
// bstream << pkt;

固定缓冲区版本 #

如果不需要动态内存，也可以做一个和你原逻辑更接近的固定缓冲区实现：

class FixedBinBuffer {
private:
    std::array<uint8_t, 100> buf;
    size_t offset = 0;
public:
    FixedBinBuffer() = default;

    // 各类类型的重载和上面的BinaryOStream一致，写入到buf的offset位置即可
    FixedBinBuffer& operator<<(uint32_t val) {
        buf[offset++] = static_cast<uint8_t>((val >> 24) & 0xFF);
        buf[offset++] = static_cast<uint8_t>((val >> 16) & 0xFF);
        buf[offset++] = static_cast<uint8_t>((val >> 8) & 0xFF);
        buf[offset++] = static_cast<uint8_t>(val & 0xFF);
        return *this;
    }

    FixedBinBuffer& operator<<(uint8_t val) {
        buf[offset++] = val;
        return *this;
    }

    const uint8_t* data() const { return buf.data(); }
    size_t size() const { return offset; }
};

使用方式和你原逻辑几乎完全一致：

FixedBinBuffer buffer;
buffer << 42U << 17U;
write(fd, buffer.data(), buffer.size());

注意事项 #

• 串口/网络传输建议统一指定传输端序，避免不同设备端序不一致导致解析错误
• 处理浮点数时需要确认收发双方都使用IEEE754格式，先把浮点数转成对应位宽的无符号整数再写入
• 固定缓冲区实现要加边界检查，避免写入数据超过缓冲区大小溢出

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