C++结构体文件读写 二进制序列化实现（读写.结构.文件.序列化...）

wufei123 发布于 2025-08-29 阅读（4）
C++结构体二进制序列化需区分简单与复杂类型：对仅含基本类型的结构体，可用write()和read()配合reinterpret_cast直接读写内存；但含std::string、std::vector等动态成员时，必须手动先写入长度再写内容，读取时逆序操作。直接按内存布局序列化存在风险，主因包括编译器内存对齐导致的填充字节、不同平台字节序差异、指针或动态内存无法正确保存，以及结构体版本变更后兼容性问题。为保障可移植性和扩展性，应避免裸reinterpret_cast，转而采用分字段序列化，并在文件头加入版本号，根据版本分支处理新增、删除或修改的字段，提升数据持久化鲁棒性。

c++结构体文件读写 二进制序列化实现

C++结构体要实现文件读写和二进制序列化，核心在于将结构体的内存内容直接写入文件，或从文件读取到结构体内存中。这通常通过

fstream
的
read()
和
write()
成员函数，配合
reinterpret_cast
和
sizeof
操作来完成，从而实现数据的持久化存储。 解决方案

实现C++结构体的二进制序列化，最直接的方式是利用文件流的二进制读写功能。我们以一个简单的结构体为例：

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

// 简单结构体，不包含复杂类型
struct SimpleData {
    int id;
    double value;
    char name[20]; // 固定大小字符数组
};

// 包含复杂类型的结构体
struct ComplexData {
    int id;
    std::string description; // 动态大小字符串
    std::vector<int> numbers; // 动态大小数组
    float weight;
};

// 写入SimpleData到文件
void writeSimpleData(const std::string& filename, const SimpleData& data) {
    std::ofstream ofs(filename, std::ios::binary | std::ios::out);
    if (!ofs.is_open()) {
        std::cerr << "错误：无法打开文件 " << filename << std::endl;
        return;
    }
    ofs.write(reinterpret_cast<const char*>(&data), sizeof(SimpleData));
    ofs.close();
    std::cout << "SimpleData 写入成功。" << std::endl;
}

// 从文件读取SimpleData
SimpleData readSimpleData(const std::string& filename) {
    SimpleData data = {}; // 初始化
    std::ifstream ifs(filename, std::ios::binary | std::ios::in);
    if (!ifs.is_open()) {
        std::cerr << "错误：无法打开文件 " << filename << std::endl;
        return data;
    }
    ifs.read(reinterpret_cast<char*>(&data), sizeof(SimpleData));
    ifs.close();
    std::cout << "SimpleData 读取成功。" << std::endl;
    return data;
}

// 写入ComplexData到文件（需要自定义逻辑）
void writeComplexData(const std::string& filename, const ComplexData& data) {
    std::ofstream ofs(filename, std::ios::binary | std::ios::out);
    if (!ofs.is_open()) {
        std::cerr << "错误：无法打开文件 " << filename << std::endl;
        return;
    }

    // 写入id和weight
    ofs.write(reinterpret_cast<const char*>(&data.id), sizeof(data.id));
    ofs.write(reinterpret_cast<const char*>(&data.weight), sizeof(data.weight));

    // 写入description
    size_t desc_len = data.description.length();
    ofs.write(reinterpret_cast<const char*>(&desc_len), sizeof(desc_len));
    ofs.write(data.description.c_str(), desc_len);

    // 写入numbers
    size_t vec_size = data.numbers.size();
    ofs.write(reinterpret_cast<const char*>(&vec_size), sizeof(vec_size));
    if (vec_size > 0) {
        ofs.write(reinterpret_cast<const char*>(data.numbers.data()), vec_size * sizeof(int));
    }

    ofs.close();
    std::cout << "ComplexData 写入成功。" << std::endl;
}

// 从文件读取ComplexData（需要自定义逻辑）
ComplexData readComplexData(const std::string& filename) {
    ComplexData data = {};
    std::ifstream ifs(filename, std::ios::binary | std::ios::in);
    if (!ifs.is_open()) {
        std::cerr << "错误：无法打开文件 " << filename << std::endl;
        return data;
    }

    // 读取id和weight
    ifs.read(reinterpret_cast<char*>(&data.id), sizeof(data.id));
    ifs.read(reinterpret_cast<char*>(&data.weight), sizeof(data.weight));

    // 读取description
    size_t desc_len;
    ifs.read(reinterpret_cast<char*>(&desc_len), sizeof(desc_len));
    if (desc_len > 0) {
        data.description.resize(desc_len);
        ifs.read(&data.description[0], desc_len);
    }

    // 读取numbers
    size_t vec_size;
    ifs.read(reinterpret_cast<char*>(&vec_size), sizeof(vec_size));
    if (vec_size > 0) {
        data.numbers.resize(vec_size);
        ifs.read(reinterpret_cast<char*>(data.numbers.data()), vec_size * sizeof(int));
    }

    ifs.close();
    std::cout << "ComplexData 读取成功。" << std::endl;
    return data;
}

// int main() {
//     // SimpleData 示例
//     SimpleData s_out = {101, 3.14, "HelloStruct"};
//     writeSimpleData("simple_data.bin", s_out);
//     SimpleData s_in = readSimpleData("simple_data.bin");
//     std::cout << "读取到的 SimpleData: id=" << s_in.id << ", value=" << s_in.value << ", name=" << s_in.name << std::endl;

//     std::cout << "\n-------------------\n" << std::endl;

//     // ComplexData 示例
//     ComplexData c_out = {202, "这是一个复杂的结构体", {1, 2, 3, 4, 5}, 99.8f};
//     writeComplexData("complex_data.bin", c_out);
//     ComplexData c_in = readComplexData("complex_data.bin");
//     std::cout << "读取到的 ComplexData: id=" << c_in.id << ", description=" << c_in.description << ", weight=" << c_in.weight << std::endl;
//     std::cout << "Numbers: ";
//     for (int num : c_in.numbers) {
//         std::cout << num << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }

上面的代码展示了两种情况：一种是结构体只包含基本类型和固定大小数组，可以直接对整个结构体进行读写；另一种是结构体包含

std::string
和
std::vector
等复杂类型，这就需要我们手动处理其长度和内容。 为什么直接使用
reinterpret_cast
读写结构体存在风险？

虽然直接

reinterpret_cast
看起来很方便，但这种做法其实暗藏不少“坑”，尤其是在跨平台或结构体定义发生变化时，问题就暴露无遗了。我个人在项目中遇到过几次因为这个导致的诡异bug，排查起来简直让人头大。

一个主要的问题是内存对齐（Padding）。C++编译器为了提高内存访问效率，可能会在结构体成员之间插入一些填充字节。这意味着

sizeof(MyStruct)
不一定等于其所有成员大小之和。当你直接把整个结构体内存写入文件，然后又在另一个环境（比如不同的操作系统、不同的编译器版本，甚至是相同的编译器但编译选项不同）读取时，如果内存对齐规则不一致，读出来的数据就会错位，导致解析失败。想想看，你写了一个
int
，后面跟着一个
char
，结果读回来的时候，
char
前面多了一两个字节的“垃圾数据”，那可不就乱套了嘛。

然后是字节序（Endianness）。不同的CPU架构处理多字节数据（如

int
, 
long
, 
float
, 
double
）时，存储字节的顺序可能不同。例如，Intel x86架构是小端序（Little-Endian），而某些ARM或PowerPC架构可能是大端序（Big-Endian）。如果你在一台小端序机器上写入了一个
int
值，然后在另一台大端序机器上直接读取，这个
int
的值就会颠倒，完全不是你想要的数据。这就像你用中文写了一封信，结果对方用日文的阅读习惯去读，那肯定驴唇不对马嘴。

再者，如果结构体中包含指针或动态分配的内存（比如

std::string
、
std::vector
、或者你自己
new
出来的数组），直接
reinterpret_cast
是绝对行不通的。你序列化进去的只是指针的地址值，而不是它指向的实际数据。当程序重新启动，或者在另一个进程中读取时，那个地址值是毫无意义的，甚至可能指向了无效内存，直接导致程序崩溃。这种问题通常是最难调试的，因为崩溃可能发生在任何访问到这个“野指针”的地方。

最后，版本兼容性也是个大问题。一旦你的结构体定义发生了变化，比如你添加了一个新成员，或者删除了一个旧成员，那么旧的数据文件就可能无法被新程序正确读取，反之亦然。直接的二进制序列化缺乏元数据，无法判断文件是哪个版本，也无法知道如何跳过新增的字段或者处理缺失的字段。

如何处理结构体中的复杂数据类型（如
std::string
和
std::vector
）？

处理

std::string
和
std::vector
这类动态大小的复杂数据类型，就不能简单地用
sizeof
和
reinterpret_cast
一概而论了。我们需要更精细、更“手动”的控制。这就像你要打包行李，不能直接把整个衣柜扔进去，得一件件叠好放进去。

对于

std::string
，其核心是字符序列和长度。我们通常的做法是：
  1. 先写入字符串的长度：通常用
    size_t
    类型来存储，因为它可以表示字符串的最大可能长度。将这个长度值以二进制形式写入文件。
  2. 再写入字符串的实际字符数据：获取
    std::string
    的C风格字符串指针（
    c_str()
    或
    data()
    ），然后根据之前写入的长度，将这些字符写入文件。 读取时，过程反过来：
  3. 先读取字符串的长度：从文件中读取一个
    size_t
    值，得到字符串的预期长度。
  4. 根据长度分配内存并读取字符：根据读取到的长度，为
    std::string
    预留足够的空间（
    resize()
    ），然后将对应数量的字符从文件中读取到
    std::string
    的内部缓冲区。

对于

std::vector
，思路类似，因为它也是一个动态大小的容器：
  1. 先写入
    vector
    的元素数量：同样用
    size_t
    来存储
    vector.size()
    ，并写入文件。
  2. 然后遍历
    vector
    ，逐个写入每个元素：如果
    vector
    存储的是基本类型（如
    int
    , 
    float
    ），可以直接将整个
    vector
    的数据块（
    vector.data()
    ）一次性写入；如果元素是自定义结构体，那么每个结构体也需要按照其自身的序列化规则进行处理。 读取时：
  3. 先读取
    vector
    的元素数量：从文件中读取
    size_t
    值。
  4. 根据数量分配内存并读取元素：
    vector
    通过
    resize()
    预留空间，然后将对应数量的元素从文件中读取到
    vector
    中。同样，如果元素是自定义结构体，也需要逐个调用其反序列化方法。

这种自定义的序列化和反序列化逻辑虽然增加了代码量，但它能够确保数据的正确性和可移植性，因为我们明确地控制了每个数据块的写入和读取方式，避免了编译器填充和字节序带来的问题。

面对结构体版本迭代，如何保持二进制序列化的兼容性？

结构体版本迭代是实际开发中不可避免的挑战，尤其对于长期运行的系统，数据格式的演变是常态。要保持二进制序列化的兼容性，简单的

reinterpret_cast
就显得捉襟见肘了。我个人经验是，这需要一些前瞻性的设计和策略，否则旧数据就可能变成“废数据”。

一个非常实用的策略是引入版本号。在你的数据文件或每个序列化的结构体开头，添加一个明确的版本号字段。当程序读取数据时，它首先读取这个版本号，然后根据版本号来决定如何解析后续的数据。比如，如果版本号是1，就用旧的解析逻辑；如果版本号是2，就用新的逻辑。这就像给你的数据文件贴上一个标签，告诉程序“我是哪个年代的产品，请用对应的说明书来理解我”。

具体到实现上，可以这样做：

  1. 在结构体中添加一个
    uint16_t
    或
    uint32_t
    的
    version
    字段，并确保它始终是第一个被序列化和反序列化的字段。
  2. 当结构体发生变化时（比如新增、删除、修改字段），增加版本号。
  3. 在反序列化函数中，根据读取到的版本号执行不同的解析路径。
    • 新增字段：新版本的数据会包含这些字段。旧版本的数据没有。在读取时，如果检测到是旧版本数据，就为新字段赋予默认值或者跳过读取；如果是新版本数据，则正常读取。通常的做法是将新字段添加到结构体的末尾，这样旧的解析器在读取到旧版本的数据时，就不会因为多余的数据而崩溃。
    • 删除字段：新版本的数据不再包含这些字段。旧版本的数据有。在读取时，如果检测到是旧版本数据，需要跳过这些已删除字段的字节，以确保后续字段能正确对齐。
    • 修改字段类型：这是最麻烦的情况，通常需要更复杂的转换逻辑，或者干脆认为是不兼容的修改，需要数据迁移工具。

除了版本号，还可以考虑更高级的“自描述”序列化方法，尽管这会增加文件大小和序列化/反序列化的复杂性。例如，不是直接写入数据，而是写入“字段ID-字段类型-字段值”的组合，或者使用TLV（Tag-Length-Value）格式。这样，即使结构体顺序或字段有增减，只要ID不变，就能找到对应的数据。但这已经接近Protobuf、FlatBuffers等成熟序列化框架的思路了，它们正是为了解决这些复杂问题而设计的。

总的来说，保持兼容性需要你在设计之初就考虑好未来可能的变化，并预留处理这些变化的机制。它不是一个一劳永逸的解决方案，而是一个持续演进的过程。

以上就是C++结构体文件读写 二进制序列化实现的详细内容，更多请关注知识资源分享宝库其它相关文章！

标签:  读写 结构 文件 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

标签列表