将二进制文件读入结构(c++)

您的结构体几乎肯定已经被填充以保持其内容的对齐。这意味着它不会是37字节，而这种不匹配会导致读取不同步。看看每个字符串丢失3个字符的方式，它似乎被填充到40个字节。

由于填充可能在字符串和整数之间，因此即使第一个记录也不能正确读取。

在这种情况下，我建议不要尝试将数据作为二进制blob读取，而是坚持读取单个字段。它要坚固得多，尤其是如果你想改变你的结构。

没有看到写入数据的代码，我猜您是按照第一个示例中读取数据的方式写入数据的，每个元素一个接一个。那么文件中的每个记录将确实是37字节。

但是，由于编译器为了优化的原因而填充结构以将成员放在良好的边界上，所以您的结构是40字节。因此，当您在一次调用中读取完整的结构时，实际上每次读取40字节，这意味着您的读取将与文件中实际记录的相位不一致。

您要么必须重新实现写入以一次写入完整的结构，要么使用第一种读取方法，每次读取一个成员字段。

一个简单的解决方法是将结构打包为1字节

使用GCC

struct __attribute__((packed)) Student
{
    char name[25];
    int quiz1;
    int quiz2;
    int quiz3;
};

使用MSVC

#pragma pack(push, 1) //set padding to 1 byte, saves previous value
struct  Student
{
    char name[25];
    int quiz1;
    int quiz2;
    int quiz3;
};
#pragma pack(pop) //restore previous pack value

编辑:正如用户汉斯所说:gcc从2.7.2.3版本(1997年发布)开始支持pragma pack，所以如果您的目标是msvc和gcc

，那么使用pragma pack作为唯一的打包符号似乎是安全的，因为您已经发现，填充是这里的问题。另外，正如其他人所建议的，解决这个问题的正确方法是像您在示例中所做的那样单独读取每个成员。我不认为这会比一次性阅读整个程序花费更多的时间。但是，如果您仍然想要读取它，您可以告诉编译器以不同的方式进行填充:

#pragma pack(push, 1)
struct Student
{
    char name[25];
    int quiz1;
    int quiz2;
    int quiz3;
};
#pragma pack(pop)

对于#pragma pack(push, 1)，您告诉编译器将当前包值保存在内部堆栈上，然后使用1的包值。这意味着您将获得1字节的对齐，这意味着在这种情况下根本没有填充。对于#pragma pack(pop)，你告诉编译器从堆栈中获取最后一个值，然后使用它，从而恢复编译器在定义struct之前使用的行为。

虽然#pragma通常表示不可移植的、依赖于编译器的特性，但这个至少适用于GCC和Microsoft vc++。

解决这个线程问题的方法不止一种。下面是基于使用结构体和char buf的联合的解决方案:

#include <fstream>
#include <sstream>
#include <iomanip>
#include <string>
/*
This is the main idea of the technique: Put the struct
inside a union. And then put a char array that is the
number of chars needed for the array.
union causes sStudent and buf to be at the exact same
place in memory. They overlap each other!
*/
union uStudent
{
    struct sStudent
    {
        char name[25];
        int quiz1;
        int quiz2;
        int quiz3;
    } field;
    char buf[ sizeof(sStudent) ];    // sizeof calcs the number of chars needed
};
void create_data_file(fstream& file, uStudent* oStudent, int idx)
{
    if (idx < 0)
    {
        // index passed beginning of oStudent array. Return to start processing.
        return;
    }
    // have not yet reached idx = -1. Tail recurse
    create_data_file(file, oStudent, idx - 1);
    // write a record
    file.write(oStudent[idx].buf, sizeof(uStudent));
    // return to write another record or to finish
    return;
}

std::string read_in_data_file(std::fstream& file, std::stringstream& strm_buf)
{
    // allocate a buffer of the correct size
    uStudent temp_student;
    // read in to buffer
    file.read( temp_student.buf, sizeof(uStudent) );
    // at end of file?
    if (file.eof())
    {
        // finished
        return strm_buf.str();
    }
    // not at end of file. Stuff buf for display
    strm_buf << std::setw(25) << std::left << temp_student.field.name;
    strm_buf << std::setw(5) << std::right << temp_student.field.quiz1;
    strm_buf << std::setw(5) << std::right << temp_student.field.quiz2;
    strm_buf << std::setw(5) << std::right << temp_student.field.quiz3;
    strm_buf << std::endl;
    // head recurse and see whether at end of file
    return read_in_data_file(file, strm_buf);
}

std::string quiz(void)
{
    /*
    declare and initialize array of uStudent to facilitate
    writing out the data file and then demonstrating
    reading it back in.
    */
    uStudent oStudent[] =
    {
        {"Bart Simpson",          75,   65,   70},
        {"Ralph Wiggum",          35,   60,   44},
        {"Lisa Simpson",         100,   98,   91},
        {"Martin Prince",         99,   98,   99},
        {"Milhouse Van Houten",   80,   87,   79}
    };


    fstream file;
    // ios::trunc causes the file to be created if it does not already exist.
    // ios::trunc also causes the file to be empty if it does already exist.
    file.open("quizzes.dat", ios::in | ios::out | ios::binary | ios::trunc);
    if ( ! file.is_open() )
    {
        ShowMessage( "File did not open" );
        exit(1);
    }

    // create the data file
    int num_elements = sizeof(oStudent) / sizeof(uStudent);
    create_data_file(file, oStudent, num_elements - 1);
    // Don't forget
    file.flush();
    /*
    We wrote actual integers. So, you cannot check the file so
    easily by just using a common text editor such as Windows Notepad.
    You would need an editor that shows hex values or something similar.
    And integrated development invironment (IDE) is likely to have such
    an editor.   Of course, not always so.
    */

    /*
    Now, read the file back in for display. Reading into a string buffer
    for display all at once. Can modify code to display the string buffer
    wherever you want.
    */
    // make sure at beginning of file
    file.seekg(0, ios::beg);
    std::stringstream strm_buf;
    strm_buf.str( read_in_data_file(file, strm_buf) );
    file.close();
    return strm_buf.str();
}

调用quiz()并接收一个格式化的字符串，用于显示std::cout、写入文件或其他。

主要思想是联合中的所有项都从内存中的同一地址开始。所以你可以有一个char或wchar_t，但它的大小与你想要写入或从文件中读取的结构体相同。注意，需要零强制转换。代码中没有强制类型转换

我也不必担心填充。

对于那些不喜欢递归的人，抱歉。对我来说，用递归来解决这个问题更容易，也更不容易出错。也许对其他人来说不容易?递归可以转换为循环。对于非常大的文件，它们需要转换为循环。

对于那些喜欢递归的人来说，这是使用递归的另一个实例。

我并不是说使用并集是最好的解决方案。似乎这是一个解决方案。也许你喜欢它?