使用二进制文件访问违规读取位置

dataFile.write(reinterpret_cast<char *>(&divisionData), sizeof(divisionData)); 

仅在您具有POD类型的情况下才能起作用。当您有std::string时，它不起作用。您需要按照以下方式使用一些东西：

// Write the size of the string.
std::string::size_type size = divisionDat.divisionName.size();
dataFile.write(reinterpret_cast<char*>(&size), sizeof(size));
// Now write the string.
dataFile.write(reinterpret_cast<char*>(divisionDat.divisionName.c_str()), size);
// Write the quarter and the sales.
dataFile.write(reinterpret_cast<char*>(&divisionDat.quarter), sizeof(divisionDat.quarter));
dataFile.write(reinterpret_cast<char*>(&divisionDat.sales), sizeof(divisionDat.sales));

更改读取调用以匹配写入调用。

// Dump struct into binary file
dataFile.write(reinterpret_cast<char *>(&divisionData), sizeof(divisionData)); 
/*...*/
// Read an object from the file, cast as DIVISION_DATA_S
dataFile.read(reinterpret_cast<char *>(&divisionData), sizeof(divisionData));

在任何情况下，这都不明确地工作。

std::string使用堆分配的指针存储其包含的任何字符串数据。您正在写入文件的内容是不是字符串的内容，而只是字符串数据所在的地址（以及一些元数据）。如果您任意阅读这些指针并将其视为内存（就像您在cout语句中一样），则会引用已删除的内存。

您有两个选择。

如果您想要的只是一个可以轻松序列化的结构，则只需像这样转换：

// Struct to hold division data
struct DIVISION_DATA_S
{
    char divisionName[500];
    int quarter;
    double sales;
};

当然，使用这种样式，您仅限于与名称作为C弦的互动，并且还限于500个字符。

另一个选项是正确序列化此对象。

// Struct to hold division data
struct DIVISION_DATA_S
{
    string divisionName;
    int quarter;
    double sales;
    string serialize() const { //Could also have the signature be std::vector<char>, but this will make writing with it easier.
        string output;
        std::array<char, 8> size_array;
        size_t size_of_string = divisionName.size();
        for(char & c : size_array) {
            c = size_of_string & 0xFF;
            size_of_string >>= 8;
        }
        output.insert(output.end(), size_array.begin(), size_array.end());
        output.insert(output.end(), divisionName.begin(), divisionName.end());
        int temp_quarter = quarter;
        for(char & c : size_array) {
            c = temp_quarter & 0xFF;
            temp_quarter >>= 8;
        }
        output.insert(output.end(), size_array.begin(), size_array.begin() + sizeof(int));
        size_t temp_sales = reinterpret_cast<size_t>(sales);
        for(char & c : size_array) {
            c = temp_sales & 0xFF;
            temp_sales >>= 8;
        }
        output.insert(output.end(), size_array.begin(), size_array.end());
        return output;
    }
    size_t unserialize(const string & input) {
        size_t size_of_string = 0;
        for(int i = 7; i >= 0; i--) {
            size_of_string <<= 8;
            size_of_string += unsigned char(input[i]);
        }
        divisionName = input.substr(7, 7 + size_of_string);
        quarter = 0;
        for(int i = 10 + size_of_string; i >= 7 + size_of_string; i--) {
            quarter <<= 8;
            quarter += unsigned char(input[i]);
        }
        size_t temp_sales = 0;
        for(int i = 18 + size_of_string; i >= 11 + size_of_string; i--) {
            temp_sales <<= 8;
            temp_sales += unsigned char(input[i]);
        }
        sales = reinterpret_cast<double>(temp_sales);
        return 8 + size_of_string + 4 + 8;
    }
};

写信给文件很容易：

dataFile << divisionData.serialize();

阅读可能会更难：

stringstream ss;
ss << dataFile.rdbuf();
string file_data = ss.str();
size_t size = divisionData.unserialize(file_data);
file_data = file_data.substr(size);
size = divisionData.unserialize(file_data);
/*...*/

顺便说一句，我尚未检查我的代码是否有语法或完整性。此示例旨在作为您需要编写的代码类型的参考，以正确地序列化/取消复杂对象。我相信是正确的，但我不仅会将其扔进未经测试中。

欢迎来到序列化世界。您正在尝试将您的结构"闪烁"到文件中。这仅适用于非常简单的类型（int，float，char [xxx]），其中数据实际上是内联的。即使它确实有效，您也会坚持将数据重新加载到相同类型的机器（相同的单词大小，相同的endianness）中。

您需要做的是串联数据，然后将其恢复。您可以自己发明自己做的方法，也可以在许多标准上使用一种方法。有两种基本类型 - 二进制（高效，不可阅读）和文本（效率较低但可读性）

文字

• json
• yaml
• xml
• CSV

二进制

• Protobuf

Boost具有序列化库http://www.boost.org/doc/libs/1_61_0/libs/serialization/doc/

您也可能想在这里看

https://isocpp.org/wiki/faq/serialization