VC++MFC在UNICODE下，将VECTOR结构体写入到二进制文件中，并读取

源码资源网

VC++MFC在UNICODE下，将VECTOR结构体写入到二进制文件中，并读取
在VC++ MFC中，将一个包含结构体的  `std::vector`  写入到二进制文件中并读取的过程如下。我们将定义一个简单的结构体，使用  `std::vector`  存储多个结构体实例，并实现写入和读取的功能。
### 示例代码

1. #include <afx.h>
   
2. #include <vector>
   
3. #include <iostream>
   
4. #include <fstream>
   
5. // 定义一个结构体
   
6. struct MyStruct {
   
7.     int id;
   
8.     CString name;
   
9.      // 构造函数
   
10.     MyStruct(int id, CString name) : id(id), name(name) {}
    
11. };
    
12. // 将结构体写入二进制文件
    
13. void WriteToBinaryFile(const std::vector<MyStruct>& myStructs, const CString& filePath) {
    
14.     CFile file;
    
15.     if (!file.Open(filePath, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary)) {
    
16.         std::cerr << "无法打开文件进行写入: " << filePath.GetString() << std::endl;
    
17.         return;
    
18.     }
    
19.      // 写入结构体数量
    
20.     int count = static_cast<int>(myStructs.size());
    
21.     file.Write(&count, sizeof(count));
    
22.      // 写入每个结构体
    
23.     for (const auto& item : myStructs) {
    
24.         // 写入id
    
25.         file.Write(&item.id, sizeof(item.id));
    
26.          // 写入name的长度
    
27.         int nameLength = item.name.GetLength();
    
28.         file.Write(&nameLength, sizeof(nameLength));
    
29.          // 写入name的内容
    
30.         file.Write(item.name.GetString(), nameLength * sizeof(TCHAR));
    
31.     }
    
32.      file.Close();
    
33. }
    
34. // 从二进制文件读取结构体
    
35. void ReadFromBinaryFile(std::vector<MyStruct>& myStructs, const CString& filePath) {
    
36.     CFile file;
    
37.     if (!file.Open(filePath, CFile::modeRead | CFile::typeBinary)) {
    
38.         std::cerr << "无法打开文件进行读取: " << filePath.GetString() << std::endl;
    
39.         return;
    
40.     }
    
41.      // 读取结构体数量
    
42.     int count = 0;
    
43.     file.Read(&count, sizeof(count));
    
44.      // 读取每个结构体
    
45.     for (int i = 0; i < count; ++i) {
    
46.         MyStruct item(0, _T("")); // 创建一个临时结构体
    
47.          // 读取id
    
48.         file.Read(&item.id, sizeof(item.id));
    
49.          // 读取name的长度
    
50.         int nameLength = 0;
    
51.         file.Read(&nameLength, sizeof(nameLength));
    
52.          // 读取name的内容
    
53.         TCHAR* nameBuffer = new TCHAR[nameLength + 1];
    
54.         file.Read(nameBuffer, nameLength * sizeof(TCHAR));
    
55.         nameBuffer[nameLength] = _T('\0'); // 添加字符串结束符
    
56.         item.name = nameBuffer; // 将读取的内容赋值给name
    
57.         delete[] nameBuffer; // 释放临时缓冲区
    
58.          myStructs.push_back(item); // 将结构体添加到vector中
    
59.     }
    
60.      file.Close();
    
61. }
    
62. int main() {
    
63.     // 创建一个结构体的向量
    
64.     std::vector<MyStruct> myStructs;
    
65.     myStructs.emplace_back(1, _T("Alice"));
    
66.     myStructs.emplace_back(2, _T("Bob"));
    
67.     myStructs.emplace_back(3, _T("Charlie"));
    
68.      // 写入到二进制文件
    
69.     CString filePath = _T("data.bin");
    
70.     WriteToBinaryFile(myStructs, filePath);
    
71.      // 清空vector并从文件读取数据
    
72.     myStructs.clear();
    
73.     ReadFromBinaryFile(myStructs, filePath);
    
74.      // 输出读取的数据
    
75.     for (const auto& item : myStructs) {
    
76.         std::wcout << L"ID: " << item.id << L", Name: " << item.name.GetString() << std::endl;
    
77.     }
    
78.      return 0;
    
79. }

复制代码

### 代码说明
1. **结构体定义**：定义了一个名为  `MyStruct`  的结构体，包含一个整数  `id`  和一个  `CString`  类型的  `name` 。
2. **写入二进制文件**：
   -  `WriteToBinaryFile`  函数接受一个  `std::vector<MyStruct>`  和文件路径作为参数。
   - 首先写入结构体的数量，然后逐个写入每个结构体的  `id`  和  `name` 。在写入  `name`  之前，先写入其长度，以便在读取时能够正确处理。
3. **读取二进制文件**：
   -  `ReadFromBinaryFile`  函数从指定的二进制文件读取数据，并将其填充到  `std::vector<MyStruct>`  中。
   - 读取结构体的数量，然后逐个读取  `id`  和  `name` ，并将其添加到向量中。
4. ** `main`  函数**：
   - 创建并填充  `myStructs`  向量。
   - 调用  `WriteToBinaryFile`  将数据写入文件。
   - 清空向量并调用  `ReadFromBinaryFile`  从文件中读取数据。
   - 输出读取的数据。
### 注意事项
- 确保在项目中正确配置 MFC 和 Unicode 设置。
- 处理文件时要注意错误处理，以确保程序的健壮性。
- 在读取  `name`  时，动态分配了内存，使用完后需要释放，以避免内存泄漏。