1 #ifndef MEMFILEMAPHELPER_H
  2 #define MEMFILEMAPHELPER_H
  3 //文件内存映射类，创建内存映射文件;创建后，可以按照内存操作方式操作文件
  4 /*
  5 文件映射问题 
  6 内存映射文件并不是简单的文件I/O操作，实际用到了Windows的核心编程技术--内存管理。
  7 所以，如果想对内存映射文件有更深刻的认识，必须对Windows操作系统的内存管理机制有清楚的认识，
  8 内存管理的相关知识非常复杂，超出了本文的讨论范畴，在此就不再赘述，感兴趣的读者可以参阅其他相关书籍。
  9 下面给出使用内存映射文件的一般方法： 
 10 
 11 首先要通过CreateFile()函数来创建或打开一个文件内核对象，这个对象标识了磁盘上将要用作内存映射文件的文件。
 12 在用CreateFile()将文件映像在物理存储器的位置通告给操作系统后，只指定了映像文件的路径，映像的长度还没有指定。
 13 为了指定文件映射对象需要多大的物理存储空间还需要通过CreateFileMapping()函数来创建一个文件映射内核对象以告诉
 14 系统文件的尺寸以及访问文件的方式。在创建了文件映射对象后，还必须为文件数据保留一个地址空间区域，并把文件数据
 15 作为映射到该区域的物理存储器进行提交。由MapViewOfFile()函数负责通过系统的管理而将文件映射对象的全部或部分
 16 映射到进程地址空间。此时，对内存映射文件的使用和处理同通常加载到内存中的文件数据的处理方式基本一样，
 17 在完成了对内存映射文件的使用时，还要通过一系列的操作完成对其的清除和使用过资源的释放。
 18 这部分相对比较简单，可以通过UnmapViewOfFile()完成从进程的地址空间撤消文件数据的映像、
 19 通过CloseHandle()关闭前面创建的文件映射对象和文件对象。
 20 */
 21 
 22 #include <Windows.h>
 23 #include <WinBase.h>
 24 #include <string>
 25 #include <iostream>
 26 using namespace std;
 27 
 28 //typedef unsigned char    byte;
 29 //typedef unsigned long   DWORD;
 30 //typedef void*            HANDLE;
 31 
 32 class CMemFileMapHelper{
 33 public:
 34     enum MemFileType{SEQ_READ=0,SEQ_WRITE,RANDOM_READ,RANDOM_WRITE,SEQ_READ_WRITE,RANDOM_READ_WRITE};
 35 protected:
 36     HANDLE m_FileHandler;//原始文件句柄
 37     HANDLE m_FileMemMapHandler;//内存映射文件句柄
 38     unsigned __int64 m_FileSize;
 39     byte* m_BaseAddr;//内存映射文件首地址,m_BaseAddr+n =>访问文件第n字节处的位置
 40     bool m_FileMapped;//是否映射
 41 public:
 42     CMemFileMapHelper(){
 43         m_FileMapped = false;
 44         m_FileHandler = NULL;
 45         m_FileMemMapHandler = NULL;
 46         m_BaseAddr = NULL;
 47         m_FileSize = 0;
 48     }
 49     ~CMemFileMapHelper(){
 50         if(m_FileMapped)
 51             ReleaseFileMapping();
 52     }
 53 
 54     void ShowError(char* errmsg){
 55         cout<<errmsg<<endl;    
 56     }
 57 
 58     //将文件加载到内存映射
 59     bool BuildFileMapping(const char* fileName,MemFileType type = SEQ_READ, unsigned __int64 view_size=0){
 60         DWORD err_code;
 61         char err_msg[100];
 62         string shared_name = GetLastFileName(fileName);
 63 
 64         //存取模式//GENERIC_READ | GENERIC_WRITE
 65         DWORD access_mode;
 66 
 67         //共享模式// FILE_SHARE_READ | FILE_SHARE_WRITE
 68         DWORD share_mode;
 69         
 70         /*文件属性:
 71         FILE_FLAG_WRITE_THROUGH        操作系统不得推迟对文件的写操作
 72         FILE_FLAG_OVERLAPPED        允许对文件进行重叠操作
 73         FILE_FLAG_NO_BUFFERING        禁止对文件进行缓冲处理。文件只能写入磁盘卷的扇区块
 74         FILE_FLAG_RANDOM_ACCESS        针对随机访问对文件缓冲进行优化
 75         FILE_FLAG_SEQUENTIAL_SCAN        针对连续访问对文件缓冲进行优化
 76         FILE_FLAG_DELETE_ON_CLOSE        关闭了上一次打开的句柄后，将文件删除。特别适合临时文件
 77         */
 78         DWORD mmf_flag; 
 79 
 80         /*打开文件方式:
 81         CREATE_NEW        创建文件；如文件存在则会出错
 82         CREATE_ALWAYS    创建文件，会改写前一个文件
 83         OPEN_EXISTING    文件必须已经存在。由设备提出要求
 84         OPEN_ALWAYS        如文件不存在则创建它
 85         TRUNCATE_EXISTING        讲现有文件缩短为零长度*/
 86         DWORD file_create_mode;
 87 
 88         /*页面内存访问方式:
 89         PAGE_EXECUTE      可执行
 90         PAGE_EXECUTE_READ    可读,可执行
 91         PAGE_EXECUTE_READWRITE 可读,可写,可执行
 92         PAGE_EXECUTE_WRITECOPY 可读,可写,可执行,以Read-on-write和copy-on-write方式共享
 93         PAGE_NOACCESS           不可访问
 94         PAGE_READONLY           只读 并且hFile对应的文件必须以GENERIC_READ形式打开。
 95         PAGE_READWRITE          可读,可写 并且hFile对应的文件必须以GENERIC_READ 和 GENERIC_WRITE形式打开。
 96         PAGE_WRITECOPY          copy-on-write保护机制 并且hFile对应的文件必须以GENERIC_READ 和 GENERIC_WRITE形式打开。
 97         PAGE_GUARD              保护,如果访问则异常(不能单独使用)
 98         PAGE_NOCACHE            不进行CPU缓存(不能单独使用)
 99         PAGE_WRITECOMBINE       write-combined优化(不能单独使用)
100         */
101         DWORD page_access_mode;
102         
103         /*虚拟页面视图访问方式
104         FILE_MAP_WRITE：一个可读写属性的文件视图被创建，保护模式为PAGE_READWRITE 
105         FILE_MAP_READ ：一个只读属性的文件视图被创建，保护模式为PAGE_READWRITE 或 PAGE_READONLY 
106         FILE_MAP_ALL_ACCESS：与FILE_MAP_WRITE模式相同
107         FILE_MAP_COPY：保护模式为PAGE_WRITECOPY时，得到一个视图文件，当你对视图文件写操作时，页面自动交换，并且你所做的修改不会损坏原始数据资料。
108         */
109         DWORD view_access;
110 
111         //文件映射为一个映像，映像的大小=> size_t view_size
112 
113         switch(type){
114         case SEQ_READ:
115             {
116                 access_mode = GENERIC_READ;
117                 share_mode = FILE_SHARE_READ;
118                 mmf_flag = FILE_FLAG_SEQUENTIAL_SCAN;
119                 file_create_mode = OPEN_EXISTING;
120                 page_access_mode = PAGE_READONLY;
121                 view_access = FILE_MAP_READ;
122                 view_size = 0;//将整个文件映射为一个映像
123             }
124             break;
125         case RANDOM_READ:
126             {
127                 access_mode = GENERIC_READ;
128                 share_mode = FILE_SHARE_READ;
129                 mmf_flag = FILE_FLAG_RANDOM_ACCESS;
130                 file_create_mode = OPEN_EXISTING;
131                 page_access_mode = PAGE_READONLY;
132                 view_access = FILE_MAP_READ;
133                 view_size = 0;
134             }
135             break;
136         case SEQ_WRITE:
137             {
138                 access_mode = GENERIC_READ | GENERIC_WRITE;
139                 share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
140                 mmf_flag = FILE_FLAG_WRITE_THROUGH;//FILE_FLAG_SEQUENTIAL_SCAN
141                 file_create_mode = CREATE_NEW;
142                 page_access_mode = PAGE_READWRITE;
143                 view_access = FILE_MAP_WRITE;
144             }
145             break;
146         case RANDOM_WRITE:
147             {
148                 access_mode = GENERIC_READ | GENERIC_WRITE;
149                 share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
150                 mmf_flag = FILE_FLAG_RANDOM_ACCESS;
151                 file_create_mode = CREATE_NEW;
152                 page_access_mode = PAGE_READWRITE;
153                 view_access = FILE_MAP_WRITE;
154             }
155             break;
156         case SEQ_READ_WRITE:
157             {
158                 access_mode = GENERIC_READ | GENERIC_WRITE;
159                 share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
160                 mmf_flag = FILE_FLAG_SEQUENTIAL_SCAN;
161                 file_create_mode = OPEN_ALWAYS;
162                 page_access_mode = PAGE_READWRITE;
163                 view_access = FILE_MAP_READ|FILE_MAP_WRITE;//FILE_MAP_ALL_ACCESS
164             }
165             break;
166         case RANDOM_READ_WRITE:
167             {
168                 access_mode = GENERIC_READ | GENERIC_WRITE;
169                 share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
170                 mmf_flag = FILE_FLAG_RANDOM_ACCESS;
171                 file_create_mode = OPEN_ALWAYS;
172                 page_access_mode = PAGE_READWRITE;
173                 view_access = FILE_MAP_READ|FILE_MAP_WRITE;//FILE_MAP_ALL_ACCESS
174             }
175             break;
176         default:
177             return false;
178         }
179 
180         //1.创建文件
181         /*
182         HANDLE CreateFile(
183         　　LPCTSTR lpFileName, //指向文件名的指针
184           　DWORD dwDesiredAccess, //访问模式（写/读）
185             DWORD dwShareMode, //共享模式
186             LPSECURITY_ATTRIBUTES lpSecurityAttributes, //指向安全属性的指针
187             DWORD dwCreationDisposition, //如何创建
188             DWORD dwFlagsAndAttributes, //文件属性
189             HANDLE hTemplateFile //用于复制文件句柄
190         );
191         返回值
192         　　如执行成功，则返回文件句柄。
193             INVALID_HANDLE_VALUE表示出错，会设置GetLastError。
194             即使函数成功，但若文件存在，且指定了CREATE_ALWAYS 或 OPEN_ALWAYS，GetLastError也会设为ERROR_ALREADY_EXISTS
195         */
196         m_FileHandler = CreateFile(fileName,access_mode,share_mode,NULL,file_create_mode,mmf_flag,NULL);
197         err_code = GetLastError();
198         switch(err_code){
199             case INVALID_HANDLE_VALUE:
200                 sprintf(err_msg,"文件打开失败");
201                 ShowError(err_msg);
202                 return false;
203                 break;
204             case ERROR_ALREADY_EXISTS:
205                 if(m_FileHandler == NULL &&(type == SEQ_WRITE || type == RANDOM_WRITE) ){
206                     sprintf(err_msg,"文件已存在");
207                     ShowError(err_msg);
208                     return false;
209                 }
210                 break;
211         }
212 
213         //2.创建文件映射    
214         /*
215         HANDLE CreateFileMapping(
216         HANDLE hFile,                       //物理文件句柄
217         LPSECURITY_ATTRIBUTES lpAttributes, //安全设置, 一般NULL
218         DWORD flProtect,                    //保护设置
219         DWORD dwMaximumSizeHigh,            //高位文件大小
220         DWORD dwMaximumSizeLow,             //低位文件大小
221         LPCTSTR lpName                      //共享内存名称
222         );
223 
224         调用CreateFileMapping的时候GetLastError的对应错误
225         ERROR_FILE_INVALID     如果企图创建一个零长度的文件映射, 应有此报
226         ERROR_INVALID_HANDLE   如果发现你的命名内存空间和现有的内存映射, 互斥量, 信号量, 临界区同名就麻烦了
227         ERROR_ALREADY_EXISTS   表示内存空间命名已经存在
228         */
229         
230         //2.1获取文件大小
231         DWORD fileSizeLow = 0,fileSizeHigh = 0;
232         if(type == SEQ_READ || type == RANDOM_READ || type == SEQ_READ_WRITE || type == RANDOM_READ_WRITE){
233             fileSizeLow = GetFileSize(m_FileHandler,&fileSizeHigh);
234             //文件长度
235             m_FileSize = ((unsigned __int64)fileSizeHigh << 32) + (unsigned __int64)fileSizeLow;
236         }
237         else
238         {
239             m_FileSize = view_size;//待创建的文件的大小
240             fileSizeHigh = view_size >> 32;
241             fileSizeLow = view_size & 0xFFFFFFFF;
242         }
243 
244         //2.2创建映射文件        
245         m_FileMemMapHandler = CreateFileMapping(m_FileHandler,NULL,page_access_mode,fileSizeHigh,fileSizeLow,shared_name.c_str());
246         err_code = GetLastError();
247         if(m_FileMemMapHandler == NULL){
248             sprintf(err_msg,"创建映射文件错误");
249             CloseHandle(m_FileHandler);
250             ShowError(err_msg);
251             return false;
252         }
253 
254         switch(err_code){
255             case ERROR_FILE_INVALID:
256                 {
257                     sprintf(err_msg,"企图创建一个零长度的文件映射错误");
258                     CloseHandle(m_FileHandler);
259                     ShowError(err_msg);
260                     return false;
261                 }
262                 break;
263             case ERROR_INVALID_HANDLE:
264                 {
265                     sprintf(err_msg,"你的命名内存空间和现有的内存映射, 互斥量, 信号量, 临界区同名");
266                     CloseHandle(m_FileHandler);
267                     ShowError(err_msg);
268                     return false;
269                 }
270                 break;
271             case ERROR_ALREADY_EXISTS:
272                 {
273                     sprintf(err_msg,"内存空间命名已经存在");
274                     CloseHandle(m_FileHandler);
275                     ShowError(err_msg);
276                     return false;
277                 }
278                 break;
279         }
280         
281         //3.加载映射文件
282         /*
283         LPVOID   MapViewOfFile(
284         HANDLE   hFileMappingObject,   //物理文件句柄
285         DWORD   dwDesiredAccess,       //对文件数据的访问方式
286         DWORD   dwFileOffsetHigh,      //文件的偏移地址高位
287         DWORD   dwFileOffsetLow,       //文件的偏移地址低位
288         DWORD   dwNumberOfBytesToMap);   
289 
290         文件的偏移地址由DWORD型的参数dwFileOffsetHigh和dwFileOffsetLow组成的64位值来指定，
291         而且必须是操作系统的分配粒度的整数倍,对于Windows操作系统，分配粒度固定为64KB
292 
293         dwNumberOfBytesToMap：映射文件部分的大小，如果为0，则映射整个文件。 
294         返回值：
295         如果成功返回返回映射视图的起始地址，如果失败返回NULL。
296 
297         在完成对映射到进程地址空间区域的文件处理后，需要通过函数UnmapViewOfFile()完成对文件数据映像的释放，该函数原型声明如下：   
298         BOOL   UnmapViewOfFile(LPCVOID   lpBaseAddress);   
299         */
300 
301         //3.1动态获取当前操作系统的分配粒度：   
302         /*SYSTEM_INFO   sinf;   
303         GetSystemInfo(&sinf);   
304         DWORD   dwAllocationGranularity   =   sinf.dwAllocationGranularity;  
305         if(type == SEQ_WRITE || type == RANDOM_WRITE){
306         int imod = view_size % dwAllocationGranularity;
307         if(imod != 0) 
308         view_size = (1+(view_size / dwAllocationGranularity))*dwAllocationGranularity;
309         }*/
310 
311         //3.2把文件数据映射到进程的地址空间
312         m_BaseAddr = (byte*)MapViewOfFile(m_FileMemMapHandler,view_access,0,0,view_size);
313         if(m_BaseAddr != NULL){
314             m_FileMapped = true;
315             return true;
316         }
317         else{
318             sprintf(err_msg,"文件数据映射到进程的地址空间错误");
319             CloseHandle(m_FileMemMapHandler);
320             CloseHandle(m_FileHandler);
321             ShowError(err_msg);
322             return false;
323         }
324     }
325 
326     bool ReleaseFileMapping(){
327         /*
328         在完成对映射到进程地址空间区域的文件处理后，需要通过函数UnmapViewOfFile()完成对文件数据映像的释放，该函数原型声明如下：   
329         BOOL   UnmapViewOfFile(LPCVOID   lpBaseAddress);   // lpBaseAddress 映射视图起始地址
330         */
331         if(!m_FileMapped || m_BaseAddr == NULL) return false;
332         //1.释放文件数据映像
333         UnmapViewOfFile(m_BaseAddr);
334         //2.关闭内存映射句柄
335         CloseHandle(m_FileMemMapHandler);
336         //3.关闭进行内存映射的文件
337         CloseHandle(m_FileHandler);
338         m_FileMapped = false;
339         m_FileHandler = NULL;
340         m_FileMemMapHandler = NULL;
341         m_BaseAddr = NULL;
342         m_FileSize = 0;
343         return true;
344     }
345     string GetLastFileName(const char* pathName){
346         char spliter = ‘\\‘;
347         int pos = strlen(pathName);
348         for(;pos>=0 &&(*(pathName+pos)) != spliter; pos--);
349         const char* fname = pathName + (pos + 1);
350         string fileName(fname);
351         return fileName;
352     }
353     bool IsFileMapped(){
354         return m_FileMapped;
355     }
356     unsigned __int64 GetCurFileSize(){
357         if(m_FileMapped)
358             return m_FileSize;
359         else
360             return -1;
361     }
362     byte* GetMemFileBaseAddr()const{
363         if(m_FileMapped)
364             return m_BaseAddr;
365         else
366             return NULL;
367     }
368 
369     //从相对m_BaseAddr首地址offset位置拷贝len长度的数据到dst;确保dst有足够的内存空间
370     bool GetMemory(void* dst,unsigned __int64 offset, size_t len){
371         if(offset + len > m_FileSize) return false;
372         memcpy(dst,m_BaseAddr+offset,len);
373         return true;
374     }
375     //向相对m_BaseAddr首地址offset位置写入len长度的src数据;确保src有足够的内存空间
376     bool WriteMemory(void* src,unsigned __int64 offset, size_t len){
377         /*在使用内存映射文件时，为了提高速度，系统将文件的数据页面进行高速缓存，
378         而且在处理文件映射视图时不立即更新文件的磁盘映像。
379         为解决这个问题可以考虑使用FlushViewOfFile()函数，
380         该函数强制系统将修改过的数据部分或全部重新写入磁盘映像，
381         从而可以确保所有的数据更新能及时保存到磁盘。  
382 
383         将内存复制到所映射的物理文件上面
384         FlushMapViewOfFile函数可以将内存里面的内容DUMP到物理磁盘上面
385         FlushViewOfFile 把文件映射视图中的修改的内容或全部写回到磁盘文件中
386         BOOL FlushViewOfFile(
387         LPCVOID lpBaseAddress,       // 修改内容的起始地址
388         DWORD dwNumberOfBytesToFlush // 修改的字节数目
389         );
390         函数执行成功返回非零。
391         */
392         if(offset + len > m_FileSize) return false;
393         memcpy(m_BaseAddr+offset,src,len);
394         FlushViewOfFile(m_BaseAddr+offset,len);//把文件映射视图中的修改的内容或全部写回到磁盘文件中
395         return true;
396     }
397 };
398 #endif

 1 // Demo.cpp : 定义控制台应用程序的入口点。
 2 //
 3 
 4 #include "stdafx.h"
 5 #include <iostream>
 6 #include <fstream>
 7 #include <string>
 8 #include "MemFileMapHelper.h"
 9 using namespace std;
10 
11 
12 typedef struct{
13     double X;
14     double Y;
15     double Z;
16 }stru_pos;
17 
18 int main(int argc, char* argv[])
19 {
20     bool flag;
21     int nSize = 10;
22     char* fileName = "F:\\Code\\cpp\\Demo\\Demo\\test.txt";
23 
24     stru_pos *posArr = new stru_pos[nSize];
25     for (int i=0;i<nSize;i++)
26     {
27         posArr[i].X = i+1;
28         posArr[i].Y = i+2;
29         posArr[i].Z = i+3;
30     }
31 
32     CMemFileMapHelper fh;
33     //seq write
34     flag = fh.BuildFileMapping(fileName,CMemFileMapHelper::SEQ_WRITE,nSize * sizeof(stru_pos));
35     if(flag){
36         fh.WriteMemory(posArr,0,nSize*sizeof(stru_pos));
37         fh.ReleaseFileMapping();
38     }
39     if(!flag) return -1;
40 
41     ////radom write
42     //flag = fh.BuildFileMapping(fileName,CMemFileMapHelper::RANDOM_WRITE,nSize * sizeof(stru_pos));
43     //if(flag){
44     //    for (int i=nSize-1;i>=0 && flag;i--)
45     //    {
46     //        flag = fh.WriteMemory(&posArr[i],i*sizeof(stru_pos),sizeof(stru_pos));
47     //        cout<<posArr[i].X <<" "<<posArr[i].Y <<" "<<posArr[i].Z<<endl;
48     //    }
49     //    fh.ReleaseFileMapping();
50     //}
51     //if(!flag) return -1;
52 
53     //seq read
54     flag = fh.BuildFileMapping(fileName,CMemFileMapHelper::SEQ_READ);
55     for (int i=0;i<nSize && flag;i++)
56     {
57         stru_pos pos;
58         flag = fh.GetMemory(&pos,i*sizeof(stru_pos),sizeof(stru_pos));
59         cout<<pos.X <<" "<<pos.Y <<" "<<pos.Z<<endl;
60     }
61     fh.ReleaseFileMapping();
62 
63     ////random read
64     //flag = fh.BuildFileMapping(fileName,CMemFileMapHelper::RANDOM_READ);
65     //for (int i=nSize - 1;i>=0 && flag;i--)
66     //{
67     //    stru_pos pos;
68     //    flag = fh.GetMemory(&pos,i*sizeof(stru_pos),sizeof(stru_pos));
69     //    cout<<pos.X <<" "<<pos.Y <<" "<<pos.Z<<endl;
70     //}
71     //fh.ReleaseFileMapping();
72 
73     ////random read write
74     //flag = fh.BuildFileMapping(fileName,CMemFileMapHelper::SEQ_READ_WRITE);
75     //stru_pos pos;
76     //flag = fh.GetMemory(&pos,5*sizeof(stru_pos),sizeof(stru_pos));
77     //cout<<pos.X <<" "<<pos.Y <<" "<<pos.Z<<endl;
78     //pos.X = pos.Y = pos.Z = 13;
79     //flag = fh.WriteMemory(&pos,5*sizeof(stru_pos),sizeof(stru_pos));
80     //cout<<pos.X <<" "<<pos.Y <<" "<<pos.Z<<endl;
81     //fh.ReleaseFileMapping();
82 
83     delete[] posArr;
84     cin>>flag;
85     return 0;
86 }