在二进制文件C ++中写入并加载结构的向量 [英] Write and load vector of structs in a binary file c++

问题描述

我真的需要你的帮助.我的代码中包含以下结构:

I really need your help. I have the following structs in my code:

    struct Field{
        char name[20];
        int type;
        int length;
    };

    struct Record{
        vector<Field> structure;
        vector<string> info;
    };

我想要做的是将我的struct Record的向量存储在一个二进制文件中，并成功地将其加载回去.问题是我的结构里面有两个向量，它们给我带来了麻烦.你能帮我吗?

What I want to do is to store a vector of my struct Record inside a binary file and to successfully load it back. The problem is that my struct has two vectors inside of it and they are causing me some trouble. Can you help me out?

推荐答案

我知道这是重复的内容，但是..我很无聊.您基本上只编写了将结构写入流的函数.首先，如果它是POD，请写出结构的大小.

I know it's a duplicate but meh.. I was bored. You basically just write functions that would write the structure to a stream. First you write the size of the structure if it's a POD.

如果不是POD，则写入每个元素的大小，然后为该元素写入数据.

If it's not POD, you write the size of each element then you write the data for the element.

在下面您可以看到writevecfield，它首先写入向量的大小.然后，它将整个POD结构写入流中. writesvecstring首先写入向量的大小.然后，它遍历向量并写出:每个字符串的大小，然后是其内容.

Below you can see for writevecfield, it writes the size of the vector first. Then it writes the entire POD structure to the stream. writesvecstring writes the size of the vector first. Then it goes through the vector and writes: the size of each string followed by its contents.

要阅读，请执行相反的操作. readvecfield从文件中读取向量的大小，因为它是第一笔写入的内容.阅读后，我们调整向量的大小，并将字段"结构的大小"量读入新向量.

To read, you do the opposite. readvecfield reads the size of the vector from the file because it was the first thing written. After reading it, we resize the vector and read "size" amount of "Field" structures into the new vector.

要读取字符串，我们也做相反的事情. readvecstring首先从文件读取向量的大小.它将向量的大小调整为读取的大小.接下来，它循环大小"的次数，因为那是文件中字符串的数量.

To read the strings, we do the opposite as well. readvecstring reads the size of the vector from the file first. It resizes the vector to the read size. Next it loops "size" amount of times because that's the amount of strings in the file.

然后，我们读取字符串的大小，调整字符串的大小，然后将内容读取到该字符串中.然后，将其添加到向量中并移至下一个字符串:首先读取大小，调整字符串大小，读取内容，然后添加至向量.

We then read the size of the string, resize a string and read the contents into that string. We then add that to the vector and move onto the next string: read the size first, resize a string, read contents, add to vector..

#include <fstream>
#include <vector>
#include <iostream>
#include <sstream>

using namespace std;


struct Field
{
    char name[20];
    int type;
    int length;
};

struct Record
{
    vector<Field> structure;
    vector<string> info;
};

void writevecfield(ostream& os, const vector<Field> &vec)
{
    typename vector<Field>::size_type size = vec.size();
    os.write((char*)&size, sizeof(size));
    os.write((char*)&vec[0], vec.size() * sizeof(Field));
}

void readvecfield(istream& is, vector<Field> &vec)
{
    typename vector<Field>::size_type size = 0;
    is.read((char*)&size, sizeof(size));
    vec.resize(size);
    is.read((char*)&vec[0], vec.size() * sizeof(Field));
}

void writevecstring(ostream& os, const vector<string> &vec)
{
    typename vector<string>::size_type size = vec.size();
    os.write((char*)&size, sizeof(size));

    for (typename vector<string>::size_type i = 0; i < size; ++i)
    {
        typename vector<string>::size_type element_size = vec[i].size();
        os.write((char*)&element_size, sizeof(element_size));
        os.write(&vec[i][0], element_size);
    }
}

void readvecstring(istream& is, vector<string> &vec)
{
    typename vector<string>::size_type size = 0;
    is.read((char*)&size, sizeof(size));
    vec.resize(size);

    for (typename vector<string>::size_type i = 0; i < size; ++i)
    {
        typename vector<string>::size_type element_size = 0;
        is.read((char*)&element_size, sizeof(element_size));
        vec[i].resize(element_size);
        is.read(&vec[i][0], element_size);
    }
}



void WriteRecord(ostream& out, const Record& r)
{
    writevecfield(out, r.structure);
    writevecstring(out, r.info);
}

void ReadRecord(istream& in, Record& r)
{
    readvecfield(in, r.structure);
    readvecstring(in, r.info);
}


int main()
{
    Record R;

    Field first = {"HELLO", 1, 20};
    Field second = {"WORLD", 2, 40};
    R.structure.push_back(first);
    R.structure.push_back(second);
    R.info.push_back("INFO FOR HELLO");
    R.info.push_back("INFO FOR WORLD");

    std::ofstream out("C:/Users/***/Desktop/Test.bin", std::ios::out | std::ios::binary);
    WriteRecord(out, R);
    out.close();

    Record RR;
    std::ifstream in("C:/Users/***/Desktop/Test.bin", std::ios::in | std::ios::binary);
    ReadRecord(in, RR);
    in.close();

    for (int i = 0; i < RR.structure.size(); ++i)
    {
        std::cout<<"Name:   "<<RR.structure[i].name<<"\n";
        std::cout<<"Type:   "<<RR.structure[i].type<<"\n";
        std::cout<<"Length: "<<RR.structure[i].length<<"\n";
        std::cout<<"INFO:   "<<RR.info[i]<<"\n\n";
    }
}

这篇关于在二进制文件C ++中写入并加载结构的向量的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！