如何在二进制文件中读取/写入结构？

Question

我正面临一个小问题。 我有一个结构体，它有一个向量。 请注意，向量在每次迭代中都是动态的。 现在，在特定的迭代中，如何将包含大小为 n 的向量的结构存储到二进制文件中？

另外，在检索时，假设我知道向量的大小，如何从二进制文件中检索包含所有存储元素的向量的结构变量？

我能够将一些内容存储到二进制文件中（因为我可以看到写入时大小增加），但是当我尝试检索元素时，我将向量的大小设置为零。

不幸的是，我必须使用标准 STL 来实现这一点，而不是使用任何第三方库。

Answer 1

你应该看看Boost Serialization 。

如果你不能使用 3rd 方库，你必须知道 C++ 不直接支持序列化。 这意味着你必须自己做。

本文展示了一种将自定义对象序列化到磁盘并取回它的好方法。 本教程将向您展示如何立即开始使用fstream 。

这是我的尝试：

编辑：由于 OP 询问如何存储/检索比记录更多的内容，因此我决定更新原始代码。

那么，发生了什么变化？ 现在有一个数组student_t apprentice[3]; 存储3个学生的信息。 整个阵列被序列化到磁盘，然后全部加载回 RAM，在那里可以读取/搜索特定记录。 请注意，这是一个非常非常小的文件（84 字节）。 在大文件上搜索记录时，我不建议使用这种方法。

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

using namespace std;


typedef struct student
{
    char name[10];
    int age;
    vector<int> grades;
}student_t;

int main()
{
    student_t apprentice[3];  
    strcpy(apprentice[0].name, "john");
    apprentice[0].age = 21;
    apprentice[0].grades.push_back(1);
    apprentice[0].grades.push_back(3);
    apprentice[0].grades.push_back(5);    

    strcpy(apprentice[1].name, "jerry");
    apprentice[1].age = 22;
    apprentice[1].grades.push_back(2);
    apprentice[1].grades.push_back(4);
    apprentice[1].grades.push_back(6);

    strcpy(apprentice[2].name, "jimmy");
    apprentice[2].age = 23;
    apprentice[2].grades.push_back(8);
    apprentice[2].grades.push_back(9);
    apprentice[2].grades.push_back(10);

    // Serializing struct to student.data
    ofstream output_file("students.data", ios::binary);
    output_file.write((char*)&apprentice, sizeof(apprentice));
    output_file.close();

    // Reading from it
    ifstream input_file("students.data", ios::binary);
    student_t master[3];
    input_file.read((char*)&master, sizeof(master));         

    for (size_t idx = 0; idx < 3; idx++)
    {
        // If you wanted to search for specific records, 
        // you should do it here! if (idx == 2) ...

        cout << "Record #" << idx << endl;
        cout << "Name: " << master[idx].name << endl;
        cout << "Age: " << master[idx].age << endl;
        cout << "Grades: " << endl;
        for (size_t i = 0; i < master[idx].grades.size(); i++)
           cout << master[idx].grades[i] << " ";
        cout << endl << endl;
    }

    return 0;
}

输出：

Record #0
Name: john
Age: 21
Grades: 
1 3 5 

Record #1
Name: jerry
Age: 22
Grades: 
2 4 6 

Record #2
Name: jimmy
Age: 23
Grades: 
8 9 10

转储二进制文件：

$ hexdump -c students.data 
0000000   j   o   h   n  \0 237   {  \0   �   �   {   � 025  \0  \0  \0
0000010   (   �   �  \b   4   �   �  \b   8   �   �  \b   j   e   r   r
0000020   y  \0   �  \0   �   �   |  \0 026  \0  \0  \0   @   �   �  \b
0000030   L   �   �  \b   P   �   �  \b   j   i   m   m   y  \0  \0  \0
0000040   �   6   �  \0 027  \0  \0  \0   X   �   �  \b   d   �   �  \b
0000050   h   �   �  \b                                                
0000054

Answer 2

您通常通过写入向量的长度，然后是该元素数来序列化向量。 当您读回它时，首先将长度放在首位让您知道作为该向量的一部分要读取多少项。 作为一个简单的第一次近似，考虑这样的事情：

template<class T>
std::ostream &operator<<(std::ostream &output, T const &input) {
    T::size_type size = input.size();

    output << size << "\n";
    std::copy(input.begin(), input.end(), 
         std::ostream_iterator<T::value_type>(output, "\n"));

    return output;
}

template<class T>
std::istream &operator>>(std::istream &input, T &output) {
    T::size_type size, i;

    input >> size;
    output.resize(size);
    std::copy_n(
        std::istream_iterator<t::value_type>(input),
        size,
        output.begin());

    return input;
}

这对许多调整、改进和简单的修改都是开放的——例如，目前，我已经通过引用传递了向量（或其他任何东西——可能是 std::deque 等）而不是传递迭代器。 这可能简化了大多数使用，但不太适合库的其余部分。

这也以文本格式序列化，每行一个数字。 之前已经讨论过将文本与二进制进行比较，因此我不会尝试在此处重复所有论点——我只是要指出，同样的基本思想可以以二进制格式和文本格式完成。