基于visual c++之windows核心编程代码分析（22）Mapping File编程

文件映射(mapping)是一种将文件内容映射到进程的虚拟地址空间的技术。视图(View)是一段虚拟地址空间，进程可以通过View来存取文件的内容，视图是一段内存，可以使用指针来操作视图。使用文件映射之后，读写文件就如同对读写内存一样简单。在使用文件映射时需要创建映射对象，映射对象分为命名的和未命名的。映射对象还存取权限。

       使用文件映射至少有3个好处，一是因为文件存储与硬盘上的，而文件视图是一段内存，使用文件映射操作时更方便；二是效率更高；三是可以在不同的进程间共享数据。     

       文件映射依赖于系统虚拟内存管理的分页机制。

关键API

 GetSystemInfo

获取系统信息，在后面的实例中用于获取系统内存分配粒度。

CreateFileMapping

创建mapping对象，函数原型如下：/×应该是创建一个文件映射的内核对象×/

CreateFileMapping(

    HANDLE hFile,

    LPSECURITY_ATTRIBUTES lpAttributes,

    DWORD dwMaximumSizeHigh,

    DWORD dwMaximumSizeLow,

    LPCTSTR lpName

);

参数

       hFile: 输入参数，由 CreateFile 创建的需要映射的文件的文件句柄。

       lpAttributes: 输入参数，指向 SECURITY_ATTRIBUTES结构的指针，在一般情况使用默认属性即可，将此参数赋为NULL。

       flProtect: 输入参数，内存保护属性，可以是 PAGE_READONLY 、PAGE_READWRITE、PAGE_WRITECOPY、PAGE_EXECUTE_READ、PAGE_EXECUTE_READWRITE 中的一种，也可以使用位或运算附加下面的属性：SECURITY_ATTRIBUTES、SEC_COMMIT、SEC_IMAGE、SEC_LARGE_PAGES、SEC_NOCACHE、SEC_RESERVE。

       dwMaximumSizeHigh:输入参数，映射大小的最大值的高32位。

       dwMaximumSizeLow:输入参数，映射大小的最大值的低32位。

       lpName:输入参数，映射对象名，可以是NULL。

返回值：

       返回HANDLE值，mapping对象句柄。如果返回NULL，则表示失败。可使用GetLastError函数获取错误信息。

 MapViewOfFile

创建视图，将文件mapping 映射到当前进程的虚拟内存地址空间。函数原型如下：

LPVOID MapViewOfFile(

    HANDLE hFileMappingObject,

    DWORD dwDesiredAccess,

    DWORD dwFileOffsetHigh,

    DWORD dwFileOffsetLow,

    SIZE_T dwNumberOfBytesToMap

);

参数

      hFileMappingObject:输入数据，文件 mapping 对象的句柄，由 CreateFileMapping  函数或OpenFileMapping函数返回。

       dwDesiredAccess:输入参数，存取类别，可以是 FILE_MAP_WRITE、FILE_MAP_READ、FILE_MAP_COPY、、FILE_MAP_EXECUTE中的一种。

       dwFileOffsetHigh:输入参数，映射的文件偏移的高32位。

       dwFileOffsetLow:输入参数，映射的文件偏移的低32位。

       dwNumberOfBytesToMap:输入参数，映射到View的字节数。

返回值：

       返回LPVOID值，指向映射的内存值，如果为NULL表示错误。

FlushViewOfFile

将视图中的文件数据写入到磁盘上。调用此参数后，对映射视图的内存操作将会及时反映到硬盘中的文件。函数原型如下：

BOOL FlushViewOfFile(

     LPVOID  lpBaseAddress,

     SIZE_T  dwNumberOfBytesToFlush

);

参数

lpBaseAddress:输入参数，需要写入至文件的数据的起始位置。

dwNumberOfBytesToFlush:输入参数，写入的字节数，如果为0则将整个视图都写回。

返回值：

返回BOOL 值，表示是否成功。

使用说明

如果不调用此函数，数据最终也会写回到硬盘，调用此函数后，数据会立刻写回到硬盘。

FillMemory、CopyMemory。内存操作函数，分别为填充内存和复制内存。

 

使用Mapping File提高文件读写的效率范例

[cpp] view plain copy

1. /* 头文件　*/  
2. #include <windows.h>  
3. #include <stdio.h>  
4. /* 预处理申明　*/  
5. #define BUFFSIZE 1024                   // 内存大小  
6. #define FILE_MAP_START 0x28804          // 文件映射的起始的位置  
7. /* 全局变量　*/  
8. LPTSTR lpcTheFile = TEXT("test.dat");   // 文件名  
9.   
10. /* ************************************ 
11. * int main(void) 
12. * 功能    演示使用文件mapping 
13. * 
14. * 参数    无 
15. * 
16. * 返回值   0代表执行完成，1代表发生错误 
17. **************************************/  
18. int main(void)  
19. {  
20.     HANDLE hMapFile;      // 文件内存映射区域的句柄  
21.     HANDLE hFile;         // 文件的句柄  
22.     DWORD dBytesWritten;  // 写入的字节数  
23.     DWORD dwFileSize;     // 文件大小  
24.     DWORD dwFileMapSize;  // 文件映射的大小  
25.     DWORD dwMapViewSize;  // 视图（View）的大小  
26.     DWORD dwFileMapStart; // 文件映射视图的起始位置  
27.     DWORD dwSysGran;      // 系统内存分配的粒度  
28.     SYSTEM_INFO SysInfo;  // 系统信息  
29.     LPVOID lpMapAddress;  // 内在映射区域的起始位置  
30.     PCHAR pData;            // 数据  
31.     INT i;                // 循环变量  
32.     INT iData;  
33.     INT iViewDelta;  
34.     BYTE cMapBuffer[32];  // 存储从mapping中计出的数据  
35.   
36.     // 创建一个文件  
37.     hFile = CreateFile(lpcTheFile,   
38.         GENERIC_READ | GENERIC_WRITE,  
39.         0,   
40.         NULL,  
41.         CREATE_ALWAYS,   
42.         FILE_ATTRIBUTE_NORMAL,   
43.         NULL);  
44.     //判断文件是否创建成功  
45.     if (hFile == INVALID_HANDLE_VALUE)  
46.     {  
47.         printf("CreateFile error\n",GetLastError);  
48.         return 1;  
49.     }  
50.     // 依次写入整数，一共写入65535个整数  
51.     // 在32位平台下，大小为65535*32  
52.     for (i=0; i<65535; i++)   
53.     {  
54.         WriteFile (hFile, &i, sizeof (i), &dBytesWritten, NULL);  
55.     }  
56.     // 查看写入完成后的文件大小  
57.     dwFileSize = GetFileSize(hFile,  NULL);  
58.     printf("文件大小: %d\n", dwFileSize);  
59.   
60.     //获取系统信息，内存分配粒度  
61.     //获取分配粒度，进行下面的几个计算，  
62.     //目的是为了映射的数据与系统内存分配粒度对齐，提高内存访问效率  
63.     GetSystemInfo(&SysInfo);  
64.     dwSysGran = SysInfo.dwAllocationGranularity;  
65.   
66.     //计算mapping的起始位置  
67.     dwFileMapStart = (FILE_MAP_START / dwSysGran) * dwSysGran;  
68.     // 计算mapping view的大小  
69.     dwMapViewSize = (FILE_MAP_START % dwSysGran) + BUFFSIZE;  
70.     // 计算mapping的大小  
71.     dwFileMapSize = FILE_MAP_START + BUFFSIZE;  
72.     // 计算需要读取的数据的偏移  
73.     iViewDelta = FILE_MAP_START - dwFileMapStart;  
74.   
75.     // 创建File mapping  
76.     hMapFile = CreateFileMapping( hFile,          // 需要映射的文件的句柄  
77.         NULL,           // 安全选项：默认  
78.         PAGE_READWRITE, // 可读，可写  
79.         0,              // mapping对象的大小，高位  
80.         dwFileMapSize,  // mapping对象的大小，低位  
81.         NULL);          // mapping对象的名字  
82.     if (hMapFile == NULL)   
83.     {  
84.         printf("CreateFileMapping error: %d\n", GetLastError() );  
85.         return 1;  
86.     }  
87.   
88.     // 映射view  
89.     lpMapAddress = MapViewOfFile(hMapFile,            // mapping对象的句柄  
90.         FILE_MAP_ALL_ACCESS, // 可读，可写  
91.         0,                   // 映射的文件偏移，高32位  
92.         dwFileMapStart,      // 映射的文件偏移，低32位  
93.         dwMapViewSize);      // 映射到View的数据大小  
94.     if (lpMapAddress == NULL)   
95.     {  
96.         printf("MapViewOfFile error: %d\n", GetLastError());  
97.         return 1;  
98.     }  
99.   
100.     printf ("文件map view相对于文件的起始位置： 0x%x\n",  
101.         dwFileMapStart);  
102.     printf ("文件map view的大小：0x%x\n",     dwMapViewSize);  
103.     printf ("文件mapping对象的大小：0x%x\n", dwFileMapSize);  
104.     printf ("从相对于map view 0x%x 字节的位置读取数据，", iViewDelta);  
105.   
106.     // 将指向数据的指针偏移，到达我们关心的地方  
107.     pData = (PCHAR) lpMapAddress + iViewDelta;  
108.     // 读取数据，赋值给变量  
109.     iData = *(PINT)pData;  
110.     // 显示读取的数据  
111.     printf ("为：0x%.8x\n", iData);  
112.   
113.     // 从mapping中复制数据，32个字节，并打印  
114.     CopyMemory(cMapBuffer,lpMapAddress,32);  
115.     printf("lpMapAddress起始的32字节是：");  
116.     for(i=0; i<32; i++)  
117.     {  
118.         printf("0x%.2x ",cMapBuffer[i]);  
119.     }  
120.     // 将mapping的前32个字节用0xff填充  
121.     FillMemory(lpMapAddress,32,(BYTE)0xff);  
122.     // 将映射的数据写回到硬盘上  
123.     FlushViewOfFile(lpMapAddress,dwMapViewSize);  
124.     printf("\n已经将lpMapAddress开始的32字节使用0xff填充。\n");  
125.   
126.     // 关闭mapping对象  
127.     if(!CloseHandle(hMapFile))   
128.     {  
129.         printf("\nclosing the mapping object error %d!",  
130.             GetLastError());  
131.     }  
132.     //关闭文件  
133.     if(!CloseHandle(hFile))   
134.     {  
135.         printf("\nError %ld occurred closing the file!",  
136.             GetLastError());  
137.     }  
138.   
139.     return 0;  
140. }  

 

 通过Mapping File在进程间共享内存

 

[cpp] view plain copy

1. /* 头文件　*/  
2. #include <windows.h>  
3. #include <stdio.h>  
4. #include <conio.h>  
5. /* 预处理申明　*/  
6. #define BUF_SIZE 256  
7. /* 全局变量　*/  
8. LPTSTR szName = TEXT("SharedFileMappingObject");  
9. LPTSTR szMsg = TEXT("进程的消息");  
10.   
11. /* ************************************ 
12. * int main(void) 
13. * 功能    演示文件mapping共享内存，写入数据到共享内存 
14. * 
15. * 参数    无 
16. * 
17. * 返回值   0代表执行完成，代表发生错误 
18. **************************************/  
19. void main(int argc, PCHAR argv[])  
20. {  
21.     //文件映射句柄  
22.     HANDLE hMapFile;  
23.     //共享数据缓冲区指针  
24.     LPTSTR pBuf;  
25.     //创建命名的文件映射，不代表任务硬盘上的文件  
26.     hMapFile = CreateFileMapping(  
27.         INVALID_HANDLE_VALUE,  
28.         NULL,   
29.         PAGE_READWRITE,  
30.         0,  
31.         BUF_SIZE,   
32.         szName);  
33.     if (hMapFile == NULL || hMapFile == INVALID_HANDLE_VALUE)   
34.     {   
35.         printf("CreateFileMapping error: %d\n", GetLastError());  
36.         return;  
37.     }  
38.     //创建View  
39.     pBuf = (LPTSTR) MapViewOfFile(hMapFile,  
40.         FILE_MAP_ALL_ACCESS,  
41.         0,                     
42.         0,                     
43.         BUF_SIZE);  
44.     if (pBuf == NULL)   
45.     {   
46.         printf("MapViewOfFile error %d\n",  GetLastError());   
47.         return;  
48.     }  
49.     //将共享数据复制到文件映射中，如果运行时输入了参数则使用参数  
50.     if(argc==1)  
51.     {  
52.         CopyMemory((PVOID)pBuf, szMsg, strlen(szMsg));  
53.     }  
54.     else  
55.     {  
56.         DWORD dwCopyLen = (lstrlen(argv[1])<BUF_SIZE) ? lstrlen(argv[1]): BUF_SIZE;  
57.         CopyMemory((PVOID)pBuf, argv[1], dwCopyLen);  
58.     }  
59.     printf("运行程序，完成运行后，按任意键退出。");  
60.     _getch();  
61.     //取消映射，退出  
62.     UnmapViewOfFile(pBuf);  
63.     CloseHandle(hMapFile);  
64. }  

通过Mapping File在进程间共享内存通过Mapping File在进程间共享内存通过Mapping File在进程间共享内存

[cpp] view plain copy

1. #include <windows.h>  
2. #include <stdio.h>  
3. #include <conio.h>  
4. /* 预处理申明*/  
5. #pragma comment (lib, "User32.lib")  
6. #define BUF_SIZE 256  
7. /* 全局变量　*/  
8. TCHAR szName[]=TEXT("SharedFileMappingObject");  
9.   
10. /* ************************************ 
11. * int main(void) 
12. * 功能    演示文件mapping共享内存，从共享数据中读信息 
13. * 
14. * 参数    无 
15. * 
16. * 返回值   0代表执行完成，代表发生错误 
17. **************************************/  
18. void main()  
19. {  
20.     HANDLE hMapFile;  
21.     LPTSTR pBuf;  
22.     //打开文件mapping  
23.     hMapFile = OpenFileMapping(  
24.         FILE_MAP_ALL_ACCESS,  
25.         FALSE,  
26.         szName);   
27.     if (hMapFile == NULL)   
28.     {   
29.         printf("OpenFileMapping error: %d.\n",  GetLastError());  
30.         return;  
31.     }   
32.     //映射  
33.     pBuf = MapViewOfFile(hMapFile,  
34.         FILE_MAP_ALL_ACCESS,  
35.         0,                      
36.         0,                      
37.         BUF_SIZE);    
38.     if (pBuf == NULL)   
39.     {   
40.         printf("MapViewOfFile error %d\n", GetLastError());   
41.         return;  
42.     }  
43.     //消息得到的共享数据  
44.     MessageBox(NULL, pBuf, TEXT("Process2"), MB_OK);  
45.     //取消mapping，关闭句柄，返回  
46.     UnmapViewOfFile(pBuf);  
47.     CloseHandle(hMapFile);  
48. }