使用reinterpret_cast序列化非数组平凡可拷贝类型至缓冲区出错

问题场景 #

针对非数组平凡可拷贝类型，通过reinterpret_cast<T*>(...)转为unsigned char*后用std::copy写入自定义ByteBuffer缓冲区，反序列化时反向操作读取数据：

• 单一类型序列化/反序列化完全正常
• 混合int、double、自定义struct等不同类型时，读取结果出现异常

典型复现代码 #

#include <vector>
#include <algorithm>
#include <cstdint>

struct ByteBuffer {
    std::vector<unsigned char> buf;

    template<typename T>
    void write(const T& data) {
        const unsigned char* ptr = reinterpret_cast<const unsigned char*>(&data);
        std::copy(ptr, ptr + sizeof(T), std::back_inserter(buf));
    }

    template<typename T>
    T read() {
        T data;
        unsigned char* ptr = reinterpret_cast<unsigned char*>(&data);
        std::copy(buf.begin(), buf.begin() + sizeof(T), ptr);
        buf.erase(buf.begin(), buf.begin() + sizeof(T));
        return data;
    }
};

struct A {
    int x;
    double y;
};

int main() {
    ByteBuffer bb;
    bb.write(123); // int类型
    bb.write(45.67); // double类型
    bb.write(A{789, 0.123}); // 自定义struct

    int a = bb.read<int>();
    double b = bb.read<double>();
    A c = bb.read<A>();

    // 此处读取的b、c值大概率与写入值不符
    return 0;
}

核心问题根源 #

1. 内存对齐填充缺失/不匹配 #

不同类型的内存对齐要求存在差异：

• int通常要求4字节对齐，double要求8字节对齐
• 自定义struct的对齐规则是取成员中最大的对齐要求，比如上面的struct A，因为double需要8字节对齐，编译器会在int成员后自动填充4字节，最终sizeof(A)是16而非4+8=12

如果序列化时错误地只写入成员的实际数据字节（而非包含填充的sizeof(T)），或者反序列化时没有读取完整的sizeof(T)字节，就会导致缓冲区数据偏移错乱，后续类型读取全部出错。

2. 缓冲区越界访问（隐性问题） #

如果写入时的字节数累计与读取时的字节数累计不匹配，会触发缓冲区越界读取，直接读取到内存垃圾数据，表现为读取结果异常。

验证与修复方案 #

第一步：验证对齐问题 #

先打印各类型的实际大小与对齐要求，确认填充存在：

#include <iostream>
#include <type_traits>

int main() {
    std::cout << "int size: " << sizeof(int) << ", align: " << alignof(int) << std::endl;
    std::cout << "double size: " << sizeof(double) << ", align: " << alignof(double) << std::endl;
    std::cout << "struct A size: " << sizeof(A) << ", align: " << alignof(A) << std::endl;
    return 0;
}

运行后会看到struct A的大小为16，证明存在对齐填充。

第二步：修复ByteBuffer代码 #

确保写入/读取严格使用sizeof(T)，并添加边界检查：

#include <vector>
#include <algorithm>
#include <cstdint>
#include <stdexcept>

struct ByteBuffer {
    std::vector<unsigned char> buf;

    template<typename T>
    void write(const T& data) {
        // 强制约束仅处理平凡可拷贝类型
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
        const unsigned char* ptr = reinterpret_cast<const unsigned char*>(&data);
        buf.insert(buf.end(), ptr, ptr + sizeof(T));
    }

    template<typename T>
    T read() {
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
        // 检查缓冲区是否有足够数据
        if (buf.size() < sizeof(T)) {
            throw std::runtime_error("Insufficient data in ByteBuffer");
        }
        T data;
        unsigned char* ptr = reinterpret_cast<unsigned char*>(&data);
        std::copy(buf.begin(), buf.begin() + sizeof(T), ptr);
        buf.erase(buf.begin(), buf.begin() + sizeof(T));
        return data;
    }
};

// 测试代码不变
struct A { int x; double y; };
int main() {
    try {
        ByteBuffer bb;
        bb.write(123);
        bb.write(45.67);
        bb.write(A{789, 0.123});

        int a = bb.read<int>();
        double b = bb.read<double>();
        A c = bb.read<A>();

        std::cout << "int: " << a << std::endl;
        std::cout << "double: " << b << std::endl;
        std::cout << "struct A x: " << c.x << ", y: " << c.y << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

额外注意事项 #

• 永远不要手动计算类型的成员总字节数，必须使用sizeof(T)，它已经包含了编译器自动添加的对齐填充
• 用static_assert约束类型为平凡可拷贝，避免触发未定义行为
• 跨平台使用时，还需要处理字节序问题：序列化前将数值类型转为统一字节序（如大端），读取时再转换回本地字节序

内容的提问来源于stack exchange，提问作者R. Absil