windows C++：进程间通信高及时性、安全、数据量大的通信方式（一）文件映 ...

       
目录
一、文件映射 (File Mapping)
1. 简单的介绍
2. 文件映射的优势
3. 必要用到的API
CreateFile
CreateFileMapping
MapViewOfFile
UnmapViewOfFile
CloseHandle
4. 安全性
二、文件映射底层原理
1. 文件系统与文件句柄
2. 创建文件映射对象
3. 内存管理器与捏造内存
4. 共享内存
5. 文件映射的拆解
关键数据结构和函数
底层调用流程图
三、父子进程间通信的示例
四、优、缺点总结
长处：
缺点：
总结
五、改进

sharedMemoryW.cpp：

---

        windows进程间通信是写多进程步伐的必修课，高及时性、安全、数据量大的通信方式是很必要的，今天我们来看看文件映射
一、文件映射 (File Mapping)

1. 简单的介绍

        文件映射通过将文件的部门或全部内容映射到一个或多个进程的捏造地址空间，使得这些进程可以像访问普通内存一样访问文件内容。这个过程涉及以下步骤：

• 创建或打开文件：进程首先必要创建或打开一个文件。
  
• 创建文件映射对象：通过调用 Windows API 函数 CreateFileMapping，创建一个文件映射对象。这个对象表现文件的映射视图。
  
• 映射视图到内存：使用 MapViewOfFile 函数将文件映射对象的一个视图映射到进程的地址空间中。
  

2. 文件映射的优势

• 高及时性：文件映射将文件内容直接映射到内存，镌汰了传统 I/O 操作的开销，实现了高效的数据访问。
  
• 高安全性：可以通过设置文件和内存映射对象的权限来控制不同进程对文件的访问。
  
• 处理大数据量：得当处理大数据量的文件，通过内存映射可以高效地举行读写操作。
  
• 共享内存：在同一台计算机上的多个进程可以共享同一块内存，简化了进程间通信的复杂性。
  

3. 必要用到的API

CreateFile

        用于创建或打开一个文件。

1. HANDLE CreateFile(
2.     LPCSTR lpFileName,
3.     DWORD dwDesiredAccess,
4.     DWORD dwShareMode,
5.     LPSECURITY_ATTRIBUTES lpSecurityAttributes,
6.     DWORD dwCreationDisposition,
7.     DWORD dwFlagsAndAttributes,
8.     HANDLE hTemplateFile
9. );

复制代码

参数:

• lpFileName (LPCSTR): 文件名。
  
• dwDesiredAccess (DWORD): 访问权限。常见值包罗 GENERIC_READ、GENERIC_WRITE 等。
  
• dwShareMode (DWORD): 共享模式。常见值包罗 FILE_SHARE_READ、FILE_SHARE_WRITE 等。
  
• lpSecurityAttributes (LPSECURITY_ATTRIBUTES): 安全属性指针，可为 NULL。
  
• dwCreationDisposition (DWORD): 怎样创建文件。常见值包罗 CREATE_NEW、CREATE_ALWAYS、OPEN_EXISTING 等。
  
• dwFlagsAndAttributes (DWORD): 文件属性和标志。常见值包罗 FILE_ATTRIBUTE_NORMAL、FILE_FLAG_OVERLAPPED 等。
  
• hTemplateFile (HANDLE): 模板文件句柄，可为 NULL。
  

        为了确保文件映射的安全性，可以使用 Windows 的安全属性（SECURITY_ATTRIBUTES）来设置访问控制权限。如许可以限制哪些进程可以访问或修改映射的文件内容。
   为了确保文件映射的安全性，可以使用 Windows 的安全属性（SECURITY_ATTRIBUTES）来设置访问控制权限。这些安全属性答应您指定一个安全形貌符，该形貌符定义了哪些用户和组可以访问或修改映射的文件内容。以下是怎样使用 SECURITY_ATTRIBUTES 结构来设置访问控制权限的步骤：
  

• 创建一个安全形貌符：使用 InitializeSecurityDescriptor 函数初始化一个安全形貌符。
  
• 设置访问控制列表 (ACL)：使用 SetSecurityDescriptorDacl 函数为安全形貌符设置一个访问控制列表 (ACL)，定义访问权限。
  
• 初始化 SECURITY_ATTRIBUTES 结构：将安全形貌符包含在 SECURITY_ATTRIBUTES 结构中。
  
• 传递 SECURITY_ATTRIBUTES 结构：在调用 CreateFileMapping 或其他干系 API 时，将 SECURITY_ATTRIBUTES 结构传递给它们。
  

1.     // 定义安全描述符字符串 (SDDL)
2.     // 这里设置为允许所有用户读取和写入
3.     LPCSTR sddl = "D:P(A;;GA;;;WD)";
5.     // 创建一个安全描述符
6.     PSECURITY_DESCRIPTOR pSD = NULL;
7.     if (!ConvertStringSecurityDescriptorToSecurityDescriptorA(sddl, SDDL_REVISION_1, &pSD, NULL)) {
8.         // 处理错误
9.         printf("ConvertStringSecurityDescriptorToSecurityDescriptorA 错误: %d\n", GetLastError());
10.         return 1;
11.     }
13.     // 初始化 SECURITY_ATTRIBUTES 结构
14.     SECURITY_ATTRIBUTES sa;
15.     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
16.     sa.lpSecurityDescriptor = pSD;
17.     sa.bInheritHandle = FALSE;
19.     // 创建或打开文件
20.     HANDLE hFile = CreateFile(
21.         "example.txt",
22.         GENERIC_READ | GENERIC_WRITE,
23.         0,
24.         &sa,  // 使用自定义的安全属性
25.         CREATE_ALWAYS,
26.         FILE_ATTRIBUTE_NORMAL,
27.         NULL
28.     );

复制代码

   关键点说明：
  

• 安全形貌符字符串 (SDDL): 示例中的 SDDL "D(A;;GA;;;WD)" 设置了一个答应所有效户读取和写入的安全形貌符。您可以根据需求调整这个字符串以设置不同的权限。
  
• ConvertStringSecurityDescriptorToSecurityDescriptorA: 将 SDDL 转换为实际的安全形貌符。
  
• SECURITY_ATTRIBUTES: 包含了安全形貌符，用于设置文件和文件映射对象的安全属性。
  

  通过上述步骤和示例代码，您可以设置文件映射的安全属性，控制哪些进程可以访问或修改映射的文件内容。
          总之，文件映射是一种高效、机动的进程间通信机制，特别得当必要处理大块数据而且要求高及时性和高安全性的场景。通过合理的权限设置和内存管理，可以充分利用文件映射的优势，提高系统的整体性能。
CreateFileMapping

        用于创建一个文件映射对象。

1. HANDLE CreateFileMapping(
2.     HANDLE hFile,
3.     LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
4.     DWORD flProtect,
5.     DWORD dwMaximumSizeHigh,
6.     DWORD dwMaximumSizeLow,
7.     LPCSTR lpName
8. );

复制代码

参数:

• hFile (HANDLE): 文件句柄。
  
• lpFileMappingAttributes (LPSECURITY_ATTRIBUTES): 安全属性指针，可为 NULL。
  
• flProtect (DWORD): 保护属性。常见值包罗 PAGE_READONLY、PAGE_READWRITE 等。
  
• dwMaximumSizeHigh (DWORD): 映射文件的最大尺寸（高位）。
  
• dwMaximumSizeLow (DWORD): 映射文件的最大尺寸（低位）。
  
• lpName (LPCSTR): 文件映射对象的名字，可为 NULL。
  

返回值: 成功返回文件映射对象句柄，失败返回 NULL。

1. HANDLE hFileMapping = CreateFileMapping(
2.     hFile,
3.     NULL,
4.     PAGE_READWRITE,
5.     0,
6.     1024,
7.     "Local\\MyFileMapping"
8. );
10. if (hFileMapping == NULL) {
11.     // 处理错误
12. }

复制代码

MapViewOfFile

        将文件映射对象的一个视图映射到进程的地址空间中。

1. LPVOID MapViewOfFile(
2.     HANDLE hFileMappingObject,
3.     DWORD dwDesiredAccess,
4.     DWORD dwFileOffsetHigh,
5.     DWORD dwFileOffsetLow,
6.     SIZE_T dwNumberOfBytesToMap
7. );

复制代码

参数:

• hFileMappingObject (HANDLE): 文件映射对象句柄。
  
• dwDesiredAccess (DWORD): 访问权限。常见值包罗 FILE_MAP_READ、FILE_MAP_WRITE 等。
  
• dwFileOffsetHigh (DWORD): 文件偏移量的高位。
  
• dwFileOffsetLow (DWORD): 文件偏移量的低位。
  
• dwNumberOfBytesToMap (SIZE_T): 映射的字节数。
  

 返回值: 成功返回映射视图的指针，失败返回 NULL。

1. LPVOID lpBaseAddress = MapViewOfFile(
2.     hFileMapping,
3.     FILE_MAP_READ,
4.     0,
5.     0,
6.     0
7. );
9. if (lpBaseAddress == NULL) {
10.     // 处理错误
11. }

复制代码

UnmapViewOfFile

        排除文件视图的映射。

1. BOOL UnmapViewOfFile(
2.     LPCVOID lpBaseAddress
3. );

复制代码

1. if (!UnmapViewOfFile(lpBaseAddress)) {
2.     // 处理错误
3. }

复制代码

CloseHandle

        关闭文件、文件映射对象或文件视图的句柄。

1. BOOL CloseHandle(
2.     HANDLE hObject
3. );

复制代码

1. if (!CloseHandle(hFile)) {
2.     // 处理错误
3. }
5. if (!CloseHandle(hFileMapping)) {
6.     // 处理错误
7. }

复制代码

4. 安全性

        为了确保文件映射的安全性，可以使用 Windows 的安全属性（SECURITY_ATTRIBUTES）来设置访问控制权限。如许可以限制哪些进程可以访问或修改映射的文件内容。
        总之，文件映射是一种高效、机动的进程间通信机制，特别得当必要处理大块数据而且要求高及时性和高安全性的场景。通过合理的权限设置和内存管理，可以充分利用文件映射的优势，提高系统的整体性能。

二、文件映射底层原理

        在 Windows 底层，文件映射的实现涉及多个关键组件和机制，包罗内存管理器、文件系统、内核对象和捏造内存管理。以下是 Windows 底层实现文件映射的主要步骤和机制：
1. 文件系统与文件句柄

        当应用步伐调用 CreateFile 函数时，Windows 内核通过文件系统驱动步伐将文件打开并创建一个文件句柄。文件系统驱动步伐负责处理文件的底层访问，包罗读写操作、权限查抄和文件缓存。
2. 创建文件映射对象

        调用 CreateFileMapping 时，Windows 内核创建一个文件映射对象。这涉及到以下几个步骤：

• 分配内核对象：Windows 内核分配一个内核对象来表现文件映射对象。这个对象包含文件的元数据、权限信息和映射视图的信息。
  
• 建立文件与内存的关联：内核为文件映射对象分配一个区域，在文件和捏造内存之间建立关联。
  

3. 内存管理器与捏造内存

        当应用步伐调用 MapViewOfFile 时，Windows 内核的内存管理器开始工作：

• 捏造地址空间：内存管理器为文件映射对象分配捏造地址空间。这个捏造地址空间是应用步伐可以访问的内存区域。
  
• 页表：内存管理器更新进程的页表，将捏造地址映射到物理内存。假如物理内存不敷，内存管理器会将部门页面换出到分页文件。
  
• 懒加载：文件内容不会立刻加载到内存。当进程访问映射视图时，内存管理器通过页错误机制将所需的文件内容加载到内存。
  

4. 共享内存

        多个进程可以通过文件映射对象共享内存。不同进程调用 OpenFileMapping 和 MapViewOfFile 来访问同一个文件映射对象：

• 内核对象共享：文件映射对象在内核中是全局的，多个进程可以通过内核对象句柄访问同一文件映射对象。
  
• 捏造地址空间独立：固然捏造地址空间在每个进程中是独立的，但它们都可以映射到相同的物理内存区域，这实现了内存共享。
  

5. 文件映射的拆解

        当进程调用 UnmapViewOfFile 时，内存管理器排除文件视图的映射：

• 页表清理：内存管理器从进程的页表中移除映射条目，释放对应的捏造地址空间。
  
• 引用计数：文件映射对象有一个引用计数，当所有进程都排除映射并关闭文件映射对象时，内核释放文件映射对象和干系的资源。
  

关键数据结构和函数

• 文件映射对象：由 FILE_OBJECT 和 SECTION_OBJECT 数据结构表现。
  
• 页表（Page Table）：内存管理器使用页表来管理捏造地址到物理地址的映射。
  
• 内存管理器函数：MmCreateSection、MmMapViewOfSection、MmUnmapViewOfSection 等函数用于管理文件映射的创建、映射息争除映射。
  

底层调用流程图

1. graph TD;
2.     A[应用程序] -->|调用 CreateFile| B[文件系统驱动]
3.     B -->|返回文件句柄| A
4.     A -->|调用 CreateFileMapping| C[内核]
5.     C -->|创建文件映射对象| D[内存管理器]
6.     D -->|建立文件与内存关联| C
7.     A -->|调用 MapViewOfFile| D
8.     D -->|分配虚拟地址空间| A
9.     A -->|访问映射视图| D
10.     D -->|通过页错误加载内容| E[物理内存]
11.     A -->|调用 UnmapViewOfFile| D
12.     D -->|解除映射视图| A
13.     C -->|引用计数清零时释放资源| D

复制代码

三、父子进程间通信的示例

fileMap底子共享通信代码：

1. #include <windows.h>
2. #include <iostream>
3. #include <string>
4. #include <stdexcept>
5. #include <memory>
7. class SharedMemory {
8. public:
9.     SharedMemory(const std::wstring& name, size_t size);
10.     ~SharedMemory();
12.     bool create();
13.     bool open();
14.     void write(const std::wstring& data);
15.     std::wstring read();
16.     void close();
17.     void signal();  // 用于通知另一个进程数据已写入
18.     void wait();    // 用于等待另一个进程写入数据
20. private:
21.     std::wstring name_;
22.     size_t size_;
23.     HANDLE hFile_;
24.     HANDLE hMapFile_;
25.     LPVOID lpBase_;
26.     HANDLE hEvent_;
28.     void cleanup();
29.     void checkAndThrow(bool condition, const std::wstring& errorMessage);
30. };
35. #include "sharedMemoryW.h"
36. // 构造函数
37. SharedMemory::SharedMemory(const std::wstring& name, size_t size)
38.     : name_(name), size_(size), hFile_(NULL), hMapFile_(NULL), lpBase_(NULL), hEvent_(NULL) {}
40. // 析构函数
41. SharedMemory::~SharedMemory() {
42.     close();
43. }
45. // 创建文件映射对象和事件对象
46. bool SharedMemory::create() {
47.     hFile_ = CreateFileW(name_.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
48.     checkAndThrow(hFile_ != INVALID_HANDLE_VALUE, L"Unable to create file.");
50.     hMapFile_ = CreateFileMappingW(hFile_, NULL, PAGE_READWRITE, 0, static_cast<DWORD>(size_), name_.c_str());
51.     checkAndThrow(hMapFile_ != NULL, L"Unable to create file mapping object.");
53.     lpBase_ = MapViewOfFile(hMapFile_, FILE_MAP_ALL_ACCESS, 0, 0, size_);
54.     checkAndThrow(lpBase_ != NULL, L"Unable to map view of file.");
56.     hEvent_ = CreateEventW(NULL, TRUE, FALSE, (name_ + L"_Event").c_str());
57.     checkAndThrow(hEvent_ != NULL, L"Unable to create event object.");
59.     return true;
60. }
62. // 打开现有的文件映射对象和事件对象
63. bool SharedMemory::open() {
64.     hMapFile_ = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, name_.c_str());
65.     checkAndThrow(hMapFile_ != NULL, L"Unable to open file mapping object.");
67.     lpBase_ = MapViewOfFile(hMapFile_, FILE_MAP_ALL_ACCESS, 0, 0, size_);
68.     checkAndThrow(lpBase_ != NULL, L"Unable to map view of file.");
70.     hEvent_ = OpenEventW(EVENT_ALL_ACCESS, FALSE, (name_ + L"_Event").c_str());
71.     checkAndThrow(hEvent_ != NULL, L"Unable to open event object.");
73.     return true;
74. }
76. // 写入数据到映射内存
77. void SharedMemory::write(const std::wstring& data) {
78.     if (lpBase_ != NULL) {
79.         memcpy(lpBase_, data.c_str(), (data.size() + 1) * sizeof(wchar_t));  // 包括终止符
80.         signal(); // 通知另一个进程数据已写入
81.     }
82. }
84. // 读取数据从映射内存
85. std::wstring SharedMemory::read() {
86.     if (lpBase_ != NULL) {
87.         return std::wstring(static_cast<wchar_t*>(lpBase_));
88.     }
89.     return L"";
90. }
92. // 关闭文件映射和事件对象
93. void SharedMemory::close() {
94.     cleanup();
95. }
97. // 用于通知另一个进程数据已写入
98. void SharedMemory::signal() {
99.     if (hEvent_ != NULL) {
100.         SetEvent(hEvent_);
101.     }
102. }
104. // 用于等待另一个进程写入数据
105. void SharedMemory::wait() {
106.     if (hEvent_ != NULL) {
107.         WaitForSingleObject(hEvent_, INFINITE);
108.     }
109. }
111. void SharedMemory::cleanup() {
112.     if (lpBase_ != NULL) {
113.         UnmapViewOfFile(lpBase_);
114.         lpBase_ = NULL;
115.     }
116.     if (hMapFile_ != NULL) {
117.         CloseHandle(hMapFile_);
118.         hMapFile_ = NULL;
119.     }
120.     if (hFile_ != NULL) {
121.         CloseHandle(hFile_);
122.         hFile_ = NULL;
123.     }
124.     if (hEvent_ != NULL) {
125.         CloseHandle(hEvent_);
126.         hEvent_ = NULL;
127.     }
128. }
130. void SharedMemory::checkAndThrow(bool condition, const std::wstring& errorMessage) {
131.     if (!condition) {
132.         DWORD errorCode = GetLastError();
133.         throw std::runtime_error(std::string(errorMessage.begin(), errorMessage.end()) + " Error code: " + std::to_string(errorCode));
134.     }
135. }

复制代码

        父进程：

1. #include <windows.h>
2. #include <iostream>
3. #include <string>
4. #include "sharedMemoryW.h"
6. void CreateChildProcess(const std::wstring& sharedMemoryName, size_t sharedMemorySize) {
7.     STARTUPINFOW si;
8.     PROCESS_INFORMATION pi;
9.     ZeroMemory(&si, sizeof(si));
10.     si.cb = sizeof(si);
11.     ZeroMemory(&pi, sizeof(pi));
13.     std::wstring commandLine = L"ChildProcess.exe " + sharedMemoryName + L" " + std::to_wstring(sharedMemorySize);
15.     if (!CreateProcessW(NULL, &commandLine[0], NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
16.         std::wcerr << L"CreateProcess failed (" << GetLastError() << L")." << std::endl;
17.         return;
18.     }
20.     CloseHandle(pi.hProcess);
21.     CloseHandle(pi.hThread);
22. }
24. int main() {
25.     const std::wstring sharedMemoryName = L"SharedMemoryExample";
26.     const size_t sharedMemorySize = 1024;
28.     SharedMemory sharedMemory(sharedMemoryName, sharedMemorySize);
30.     try {
31.         sharedMemory.create();
32.     }
33.     catch (const std::exception& e) {
34.         std::cerr << "Error: " << e.what() << std::endl;
35.         return 1;
36.     }
38.     CreateChildProcess(sharedMemoryName, sharedMemorySize);
40.     std::wstring message = L"Hello from Parent Process";
41.     sharedMemory.write(message);
43.     std::wcout << L"Parent process waiting for child process to read the message..." << std::endl;
44.     sharedMemory.wait();  // 等待子进程读取数据
46.     std::wcout << L"Parent process read: " << sharedMemory.read() << std::endl;
48.     sharedMemory.close();
49.     system("pause");
50.     return 0;
51. }

复制代码

子进程：

1. #include <windows.h>
2. #include <iostream>
3. #include <string>
4. #include "sharedMemoryW.h" // 假设SharedMemory类的代码放在这个头文件中
6. int wmain(int argc, wchar_t* argv[]) {
7.     if (argc != 3) {
8.         std::wcerr << L"Usage: ChildProcess <SharedMemoryName> <SharedMemorySize>" << std::endl;
9.         return 1;
10.     }
12.     std::wstring sharedMemoryName = argv[1];
13.     size_t sharedMemorySize = std::stoull(argv[2]);
15.     SharedMemory sharedMemory(sharedMemoryName, sharedMemorySize);
17.     try {
18.         sharedMemory.open();
19.     }
20.     catch (const std::exception& e) {
21.         std::cerr << "Error: " << e.what() << std::endl;
22.         return 1;
23.     }
25.     std::wcout << L"Child process read: " << sharedMemory.read() << std::endl;
27.     std::wstring response = L"Hello from Child Process";
28.     sharedMemory.write(response);
30.     std::wcout << L"Child process waiting for parent process to read the message..." << std::endl;
31.     sharedMemory.signal();  // 通知父进程数据已写入
33.     sharedMemory.close();
35.     system("pause");
36.     return 0;
37. }

复制代码

更多代码请访问我的GitHub：
   GitHub - bowenliu1996/SharedMemoryW: Windows file mapping communication, including demo
  
四、优、缺点总结

长处：

• 高效性：共享内存答应两个或多个进程直接访问同一块内存区域，制止了频仍的数据拷贝，提高了数据传输的速度。
  
• 低耽误：共享内存通信是一种低耽误的通信方式，由于数据直接写入和读取内存，没有网络或其他中心前言的耽误。
  
• 高吞吐量：由于直接内存访问，共享内存适用于必要传输大量数据的场景，可以实现高吞吐量的数据传输。
  
• 机动性：共享内存可以用于各种类型的数据传输，无论是简单的字符串还是复杂的结构体。
  

缺点：

• 复杂的同步机制：共享内存本身不提供同步机制，必要使用额外的同步本领（如互斥锁、事件等）来确保数据读写的精确性和一致性。这增长了开发的复杂性，容易引入竞态条件（Race Conditions）。
  深刻分析：同步标题是共享内存使用中的主要挑战之一。没有精确处理同步，大概导致数据竞争、死锁、饿死等标题。这些标题不仅难以调试，而且大概导致数据损坏或步伐瓦解。
  
• 内存管理难度：必要显式地管理共享内存的分配和释放，容易导致内存泄漏或内存碎片化。
  深刻分析：内存管理错误是步伐员常犯的错误之一。在共享内存的场景中，内存泄漏不仅影响一个进程，还会影响到所有使用该共享内存的进程，大概导致系统资源耗尽。
  
• 安全性标题：共享内存区域可以被所有拥有权限的进程访问，存在潜在的安全风险。假如没有严酷的访问控制，大概导致敏感数据泄漏或被恶意窜改。
  深刻分析：安全性标题尤其在多用户环境中显得突出。恶意进程可以利用共享内存中的数据举行攻击或窜改，这必要额外的措施来保护数据的完整性和机密性。
  
• 平台依靠性：共享内存的实现通常依靠于操作系统的底层机制，不同操作系统（如Windows和Unix）的实现细节不同，导致代码的可移植性差。
  深刻分析：跨平台开发时，共享内存的实现必要针对不同平台举行适配。这增长了开发和维护成本，同时也大概导致在不同平台上出现难以预见的标题。
  
• 调试困难：共享内存调试相对困难，由于多个进程同时操作同一内存区域，调试工具和技术支持较少。
  深刻分析：调试共享内存中的标题往往必要相识多个进程的状态和行为，这增长了调试的难度和复杂性。开发人员必要具备更高的调试本领和履历。
  

总结

        共享内存通信在高效数据传输方面有显着优势，但其复杂的同步机制、内存管理、安全性标题、平台依靠性和调试困难都是使用过程中必须慎重考虑的缺点。这些缺点不仅增长了开发和维护的难度，还大概带来潜在的系统稳定性和安全性风险。因此，在使用共享内存时，必要综合权衡其优缺点，选择得当具体应用场景的通信机制。

五、改进

        根据复杂的同步机制、内存管理难度、平台依靠性、安全性标题、调试困难等标题。
我们优化代码：
sharedMemoryW.h

1. #include <windows.h>
2. #include <iostream>
3. #include <string>
4. #include <stdexcept>
5. #include <memory>
7. class SharedMemory {
8. public:
9.     SharedMemory(const std::wstring& name, size_t size);
10.     ~SharedMemory();
12.     bool create();
13.     bool open();
14.     void write(const std::wstring& data);
15.     std::wstring read();
16.     void close();
17.     void signal();  // 用于通知另一个进程数据已写入
18.     void wait();    // 用于等待另一个进程写入数据
20. private:
21.     std::wstring name_;
22.     size_t size_;
23.     HANDLE hFile_;
24.     HANDLE hMapFile_;
25.     LPVOID lpBase_;
26.     HANDLE hEvent_;
27.     HANDLE hMutex_;  // 新增的互斥锁
29.     void cleanup();
30.     void checkAndThrow(bool condition, const std::wstring& errorMessage);
31. };

复制代码

sharedMemoryW.cpp：

1. #include "sharedMemoryW.h"
3. // 构造函数
4. SharedMemory::SharedMemory(const std::wstring& name, size_t size)
5.     : name_(name), size_(size), hFile_(NULL), hMapFile_(NULL), lpBase_(NULL), hEvent_(NULL), hMutex_(NULL) {}
7. // 析构函数
8. SharedMemory::~SharedMemory() {
9.     close();
10. }
12. // 创建文件映射对象和事件对象
13. bool SharedMemory::create() {
14.     SECURITY_ATTRIBUTES sa;
15.     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
16.     sa.bInheritHandle = FALSE;
17.     sa.lpSecurityDescriptor = NULL;  // 可以自定义安全描述符
19.     hFile_ = CreateFileW(name_.c_str(), GENERIC_READ | GENERIC_WRITE, 0, &sa, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
20.     checkAndThrow(hFile_ != INVALID_HANDLE_VALUE, L"Unable to create file.");
22.     hMapFile_ = CreateFileMappingW(hFile_, NULL, PAGE_READWRITE, 0, static_cast<DWORD>(size_), name_.c_str());
23.     checkAndThrow(hMapFile_ != NULL, L"Unable to create file mapping object.");
25.     lpBase_ = MapViewOfFile(hMapFile_, FILE_MAP_ALL_ACCESS, 0, 0, size_);
26.     checkAndThrow(lpBase_ != NULL, L"Unable to map view of file.");
28.     hEvent_ = CreateEventW(&sa, TRUE, FALSE, (name_ + L"_Event").c_str());
29.     checkAndThrow(hEvent_ != NULL, L"Unable to create event object.");
31.     hMutex_ = CreateMutexW(&sa, FALSE, (name_ + L"_Mutex").c_str());
32.     checkAndThrow(hMutex_ != NULL, L"Unable to create mutex object.");
34.     return true;
35. }
37. // 打开现有的文件映射对象和事件对象
38. bool SharedMemory::open() {
39.     hMapFile_ = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, name_.c_str());
40.     checkAndThrow(hMapFile_ != NULL, L"Unable to open file mapping object.");
42.     lpBase_ = MapViewOfFile(hMapFile_, FILE_MAP_ALL_ACCESS, 0, 0, size_);
43.     checkAndThrow(lpBase_ != NULL, L"Unable to map view of file.");
45.     hEvent_ = OpenEventW(EVENT_ALL_ACCESS, FALSE, (name_ + L"_Event").c_str());
46.     checkAndThrow(hEvent_ != NULL, L"Unable to open event object.");
48.     hMutex_ = OpenMutexW(MUTEX_ALL_ACCESS, FALSE, (name_ + L"_Mutex").c_str());
49.     checkAndThrow(hMutex_ != NULL, L"Unable to open mutex object.");
51.     return true;
52. }
54. // 写入数据到映射内存
55. void SharedMemory::write(const std::wstring& data) {
56.     WaitForSingleObject(hMutex_, INFINITE);  // 加锁
57.     if (lpBase_ != NULL) {
58.         memcpy(lpBase_, data.c_str(), (data.size() + 1) * sizeof(wchar_t));  // 包括终止符
59.         signal(); // 通知另一个进程数据已写入
60.         std::wcout << L"Data written: " << data << std::endl;  // 日志记录
61.     }
62.     ReleaseMutex(hMutex_);  // 解锁
63. }
65. // 读取数据从映射内存
66. std::wstring SharedMemory::read() {
67.     WaitForSingleObject(hMutex_, INFINITE);  // 加锁
68.     std::wstring result;
69.     if (lpBase_ != NULL) {
70.         result = std::wstring(static_cast<wchar_t*>(lpBase_));
71.         std::wcout << L"Data read: " << result << std::endl;  // 日志记录
72.     }
73.     ReleaseMutex(hMutex_);  // 解锁
74.     return result;
75. }
77. // 关闭文件映射和事件对象
78. void SharedMemory::close() {
79.     cleanup();
80. }
82. // 用于通知另一个进程数据已写入
83. void SharedMemory::signal() {
84.     if (hEvent_ != NULL) {
85.         SetEvent(hEvent_);
86.         ResetEvent(hEvent_);  // 重置事件
87.     }
88. }
90. // 用于等待另一个进程写入数据
91. void SharedMemory::wait() {
92.     if (hEvent_ != NULL) {
93.         WaitForSingleObject(hEvent_, INFINITE);
94.     }
95. }
97. void SharedMemory::cleanup() {
98.     if (lpBase_ != NULL) {
99.         UnmapViewOfFile(lpBase_);
100.         lpBase_ = NULL;
101.     }
102.     if (hMapFile_ != NULL) {
103.         CloseHandle(hMapFile_);
104.         hMapFile_ = NULL;
105.     }
106.     if (hFile_ != NULL) {
107.         CloseHandle(hFile_);
108.         hFile_ = NULL;
109.     }
110.     if (hEvent_ != NULL) {
111.         CloseHandle(hEvent_);
112.         hEvent_ = NULL;
113.     }
114.     if (hMutex_ != NULL) {
115.         CloseHandle(hMutex_);
116.         hMutex_ = NULL;
117.     }
118. }
120. void SharedMemory::checkAndThrow(bool condition, const std::wstring& errorMessage) {
121.     if (!condition) {
122.         DWORD errorCode = GetLastError();
123.         throw std::runtime_error(std::string(errorMessage.begin(), errorMessage.end()) + " Error code: " + std::to_string(errorCode));
124.     }
125. }

复制代码

        如许改进优化，代码似乎安全了些。。。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。