今天在写的程序的时候,遇到字符串比较.

但是字符串可能会有大小写的区别,此时怎么办呢?忽略大小写进行比较.

利用wcsicmp就比较好, 它将字符串转换成小写字符串进行比较,这样就忽略了大小写的情况.

转自: http://blog.csdn.net/iihero/archive/2009/02/21/3918137.aspx
标 题: 赠与今年的大学毕业生

○胡　适（1932年6月27日）

 

    本文是胡适先生1932年6月27日所作。虽然30年代那个血雨腥风的时代已经过去，现在的时代已经与当时不可同日而语，但是，读来还是感觉受益匪浅，胡适先生的谆谆教导之情溢于言表。本文中，胡适先生认为，大学生毕业有三条路可走：继续做学术研究；寻着相当的职业；做官，办党，革命。文中分析了大学毕业后遇到的“陷阱堕落的方式”，并给出了三个方子。  

 

这一两个星期里，各地的大学都有毕业的班次，都有很多的毕业生离开学校去开始他们的成人事业。

 

学生的生活是一种享有特殊优待的生活，不妨幼稚一点，不妨吵吵闹闹，社会都能纵容他们，不肯严格地要他们负行为的责任。现在他们要撑起自己的肩膀来挑他们自己的担子了。在这个国难最紧急的年头，他们的担子真不轻!我们祝他们的成功，同时也不忍不依据自己的经验，赠他们几句送行的赠言——虽未必是救命毫毛，也许做个防身的锦囊罢!

 

你们毕业之后，可走的路不出这几条：绝少数的人还可以在国内或国外的研究院继续做学术研究；少数的人可以寻着相当的职业；此外还有做官，办党，革命三条路；再有就是在家享福或者失业亲居了。

 

走其余几条路的人，都不能没有堕落的危险。堕落的方式很多，总括起来，约有这两大类：

 

第一是容易抛弃学生时代求知识的欲望。你们到了实际社会里，往往学非所用，往往所学全无用处，往往可以完全用不着学问，而一样可以胡乱混饭吃，混官做。在这种环境里即使向来抱有求知识学问的人，也不免心灰意懒，把求知的欲望渐渐冷淡下去。况且学问是要有相当的设备的：书籍，实验室，师友的切磋指导，闲暇的工夫，都不是一个平常要糊口养家的人能容易办到的。没有做学问的环境，又谁能怪我们抛弃学问呢?

 

第二是容易抛弃学生时代理想的人生的追求。少年人初次和冷酷的社会接触，容易感觉理想与事实相去太远，容易发生悲观和失望。多年怀抱的人生理想，改造的热诚，奋斗的勇气，到此时候，好像全不是那么一回事了。渺小的个人在那强烈的社会炉火里，往往经不起长时期的烤炼就熔化了，一点高尚的理想不久就幻灭了。抱着改造社会的梦想而来，往往是弃甲抛兵而走，或者做了恶势的俘虏。你在那牢狱里，回想那少年气壮时代的种种理想主义，好像都成了自误误人的迷梦!从此以后，你就甘心放弃理想人生的追求，甘心做现在社会的顺民了。要防御这两方面的堕落，一面要保持我们求知识的欲望，一面要保持我们对人生的追求。

 

有什么好方子呢?依我个人的观察和经验，有三种防身的药方是值得一试的。

 

第一个方子只有一句话：“总得时时寻一两个值得研究的问题!”问题是知识学问的老祖宗：古往今来一切知识的产生与积聚，都是因为要解答问题——要解答实用上的困难和理论上的疑难。所谓“为知识而求知识”，其实也只是一种好奇心追求某种问题的解答，不过因为那种问题的性质不必是直接应用的，人们就觉得这是无所谓的求知识了。

 

我们出学校之后，离开了做学问的环境，如果没有一两个值得解答的问题在脑子里盘旋，就很难保持求学问的热心。可是，如果你有了一个真有趣的问题逗你去想它，天天引诱你去解决它，天天对你挑衅你无可奈何它——这时候，你就会同恋爱一个女子发了疯一样，坐也坐不下，睡也睡不安，没工夫也得偷出工夫去陪她，没钱也得缩衣节食去巴结她。没有书，你自会变卖家私去买书；没有仪器，你自会典押衣物去置办仪器；没有师友，你自会不远千里去寻师访友。你只要有疑难问题来逼你时时用脑子，你自然会保持发展你对学问的兴趣，即使在最贫乏的知识中，你也会慢慢地，聚起一个小图书馆来，或者设置起一所小试验室来。所以我说，第一要寻问题。脑子里没有问题之日，就是你知识生活寿终正寝之时!古人说，“待文王而兴者，凡民也。若夫豪杰之士，虽无文王犹兴。”试想伽利略和牛顿有多少藏书?有多少仪器?他们不过是有问题而已。有了问题而后他们自会造出仪器来解决他们的问题。没有问题的人们，关在图书馆里也不会用书，锁在试验室里也不会有什么发现。

 

第二个方子也只有一句话：“总得多发展一点非职业的兴趣。”离开学校之后，大家总是寻个吃饭的职业。可是你寻得的职业未必就是你所学的，未必是你所心喜的，或者是你所学的而和你性情不相近的。在这种情况之下，工作往往成了苦工，就感觉不到兴趣了。为糊口而做那种非“性之所近而力之所能勉”的工作，就很难保持求知的兴趣的生活的理想主义。最好的救济方法只有多多发展职业以外的正当兴趣与活动。

 

一个人应该有他的职业，也应该有他非职业的玩艺儿，可以叫作业余活动。往往他的业余活动比他的职业还更重要，因为一个人成就怎样，往往靠他怎样利用他的闲暇时间。他用他的闲暇来打麻将，他就成了个赌徒；你用你的闲暇来做社会服务，你也许成个社会改革者；或者你用你的闲暇去研究历史，你也许成个史学家。你的闲暇往往定你的终身。英国19世纪的两个哲人，弥儿终身做东印度公司的秘书，然而他的业余工作使他在哲学上、经济学上、政治思想史上都占一个很高的位置；斯宾塞是一个测量工程师，然而他的业余工作使他成为前世纪晚期世界思想界的一个重镇。古来成大学问的人，几乎没有一个不善用他的闲暇时间的。职业不容易适合我们的性情，我们要想生活不苦痛不堕落，只有多方发展。

 

有了这种心爱的玩艺儿，你就做六个钟头抹桌子工作也不会感觉烦闷了。因为你知道，抹了六个钟头的桌子之后，你可以回家做你的化学研究，或画完你的大幅山水，或写你的小说戏曲，或继续你的历史考据，或做你的社会改革事业。你有了这种称心如意的活动，生活就不枯寂了，精神也就不会烦闷了。

 

第三个方子也只有一句话：“你得有一点信心。”我们生当这个不幸的时代，眼中所见，耳中所闻，无非是叫我们悲观失望的。特别是在这个年头毕业的你们，眼见自己的国家民族沉沦到这步田地，眼看世界只是强权的世界，望极天边好像看不见一线的光明——在这个年头不发狂自杀，已算是万幸了，怎么还能够保持一点内心的镇定和理想的信任呢?我要对你们说：这时候正是我们要培养我们的信心的时候!只要我们有信心，我们还有救。

 

古人说：“信心可以移山。”又说：“只要功夫深，生铁磨成绣花针。”你不信吗?当拿破仑的军队征服普鲁士，占据柏林的时候，有一位教授叫作费希特的，天天在讲堂劝他的国人要有信心，要信仰他们的民族是有世界的特殊使命的，是必定要复兴的。费希特死的时候，谁也不能预料德意志统一帝国何时可以实现，然而不满５０年，新的统一的德意志帝国居然实现了。

 

一个国家的强弱盛衰，都不是偶然的，都不能逃出因果的铁律的。我们今日所受的苦痛和耻辱，都只是过去种种恶因种下的恶果。我们要收获将来的善果，必须努力种现在新因。一粒一粒地种，必有满仓满屋的收，这是我们今日应有的信心。我们要深信：今日的失败，都由于过去的不努力。我们要深信：今日的努力，必定有将来的大收成。

 

佛典里有一句话：“福不唐捐。”唐捐就是白白地丢了。我们也应该说：“功不唐捐!”没有一点努力是会白白地丢了的。在我们看不见想不到的时候，在我们看不见的方向，你瞧!你下的种子早已生根发叶开花结果了!你不信吗?法国被普鲁士打败之后，割了两省地，赔了５０万万法郎的赔款。这时候有一位刻苦的科学家巴斯德终日埋头在他的化学试验室里做他的化学试验和微菌学研究。他是一个最爱国的人，然而他深信只有科学可以救国。他用一生的精力证明了三个科学问题：(1)每一种发酵作用都是由于一种微菌的发展；(2)每一种传染病都是一种微菌在生物体内的发展；(3)传染病的微菌，在特殊的培养之下可以减轻毒力，使他们从病菌变成防病的药苗。

 

这三个问题在表面上似乎都和救国大事业没有多大关系。然而从第一个问题的证明，巴斯德定出做醋酿酒的新法，使全国的酒醋业每年减除极大的损失。从第二个问题的证明，巴斯德教全国的蚕丝业怎样选种防病，教全国的畜牧农家怎样防止牛羊瘟疫，又教全世界怎样注重消毒以减少外科手术的死亡率。从第三个问题的证明，巴斯德发明了牲畜的脾热瘟的疗治药苗，每年替法国农家减除了２０００万法郎的大损失；又发明了疯狗咬毒的治疗法，救济了无数的生命。所以英国的科学家赫胥黎在皇家学会里称颂巴斯德的功绩道：“法国给了德国５０万万法郎的赔款，巴斯德先生一个人研究科学的成就足够还清这一笔赔款了。”巴斯德对于科学有绝大的信心，所以他在国家蒙奇辱大难的时候，终不肯抛弃他的显微镜与试验室。他绝不想他在显微镜底下能偿还５０万万法郎的赔款，然而在他看不见想不到的时候，他已收获了科学救国的奇迹。

 

朋友们，在你最悲观失望的时候，那正是你必须鼓起坚强的信心的时候。你要深信：天下没有白费的努力。成功不必在我，而功力必不唐捐。

（摘自《胡适文存》第4集第4卷《胡适教育论著选》，人民教育出版社)

方子不错!
总得时时寻一两个值得研究的问题!
总得多发展一点非职业的兴趣。
你得有一点信心。

如何释放内存?

这里,我不是简单的new后要delete.是对于系统而言,我怎么做到释放内存呢?让系统的可用内存变大.从网上也看到了许多释放内存的软件,很惊异它们是如何做到的呢?

有人建议我申请一大块控件,系统不够分配了,会引起它自己去整理内存.试了一下,似乎效果不是很好.
还有人建议,这么用,向所有窗口发送一个WM_HIBERNAT消息.
PostMessage(HWND_BROADCAST, WM_HIBERNATE, 0, 0);
似乎效果也不是很好.

有没有很好的方法处理这个问题呢?

大家知道的话,指点一下啊!

万分感谢!

      过年前，从china-pub买的。一直也没有安下心来读。看今年找工作的境况，也不得不抓把紧了。也愿与c++博客的各位朋友分享我的学习心得。
       步入主题。

         这一章开篇介绍了windows函数的几种返回值：VOID，BOOL，HANDLE，PVOID，LONG/DWORD。让我们明白，仅仅通过返回值，我们是不能清楚函数调用为什么会失败的。

         windows内部，函数检测到错误会采用什么机制呢？它是采用“线程本地存储区”的机制来讲相应的错误代码与“主调线程”关联到一起。它可以使不同的线程能独立运行，不会出现相互干扰对方的错误代码的情况。

         函数返回的时候，其返回值会指出已发生的一个错误。

         我们查看具体是什么错误，在相应的函数执行完成后调用GetLastError()即可。

         windows中，错误有三种表示：
         一个消息ID（如ERROR_PATH_NOT_FOUND）
            消息文本（如the system cannot find the path specified）
         一个编号（尽量避免使用）

         调试程序的时候，我们可以配置watch窗口，让它始终显示线程的上一个错误代码和错误的文本描述。如$err,hr。hr是要显示错误代码的消息文本。不过我在windows mobile的环境下没有成功，没有弄清楚为什么。

         那么我们怎么在自己的程序中显示消息文本呢？文章介绍了利用FormatMessage函数。这里我也介绍一下这个函数的用法：
         （下面的介绍摘自：http://www.cppblog.com/bidepan2023/archive/2008/02/03/42433.html）
         DWORD FormatMessage(
             DWORD dwFlags,
             LPCVOID lpSource,
             DWORD dwMessageId,
             DWORD dwLanguageId,
             LPTSTR lpBuffer,
             DWORD nSize,
             va_list* Arguments
             );

         dwFlags:
         # FORMAT_MESSAGE_ALLOCATE_BUFFER // 此函数会分配内存以包含描述字串。
         # FORMAT_MESSAGE_FROM_SYSTEM,  // 在系统的id映射表中寻找描述字串
         # FORMAT_MESSAGE_FROM_HMODULE  // 在其他资源模块中寻找描述字串
         # FORMAT_MESSAGE_FROM_STRING   // 消息ID是个字串，不是个DWORD
         #FORMAT_MESSAGE_IGNORE_INSERTS // 允许我们获得含有%占位符的消息，不传递这个标志，就必须在Arguments参数中提供这些占位符的信息
         通常为：FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM

         lpSource:
         # 指定了FORMAT_MESSAGE_FROM_HMODULE的话，此参数表示模块的HANDLE
         # 指定了FORMAT_MESSAGE_FROM_STRING的话，此参数表示id字串
         通常为：NULL

         dwMessageId:
         消息ID;如果指定FORMAT_MESSAGE_FROM_STRING，将被忽略。

         dwLanguageId:
         消息描述所用的语言
         通常为：0表示自动选择

         lpBuffer:
         #如果未指定FORMAT_MESSAGE_ALLOCATE_BUFFER，则为自己提供的缓冲区
         #否则为系统LocalAlloc分配，需要被用户LocalFree

         nSize:
         #如果未指定FORMAT_MESSAGE_ALLOCATE_BUFFER，则为自己提供的缓冲区大小
         #否则为系统LocalAlloc分配之最小缓冲区大小

         Arguments:
         通常不使用

例子：

      这个是书中的例子的代码，我只是将它归结为了一个函数ErrorShow。这样我们在一个函数的后面调用，直接可以知道错误的原因。不过环境我是在smart device 的DEBUG环境下调时的，OutputDebugString会输出相应的字符串。

      这个例子中同时展示了FormatMessage的两种用法。观察一下第二个参数就明白了。

      visual studio 也提供了一个查询错误的小工具，为Error Lookup。通过以上的示例，我们就知道其相应的工作原理呢。

      这本书的源码的下载地址：http://wintellect.com/Books.aspx 
      大家如果对windows 编程感兴趣的话，不妨下来看看。

最近在调研文件相关的东西,如MD5值.但是文件有可能很大,所以我们不能一次读出文件.有人建议用文件映射.查了一下文件映射的内容.记录下来.
　摘自:http://www.yesky.com/405/1756405.shtml

        摘要： 本文通过内存映射文件的使用来对大尺寸文件进行访问操作，同时也对内存映射文件的相关概念和一般编程过程作了较为详细的介绍。

　　关键词： 内存映射文件；大文件处理；分配粒度

　　引言

　　文件操作是应用程序最为基本的功能之一，Win32 API和MFC均提供有支持文件处理的函数和类，常用的有Win32 API的CreateFile()、WriteFile()、ReadFile()和MFC提供的CFile类等。一般来说，以上这些函数可以满足大多数场合的要求，但是对于某些特殊应用领域所需要的动辄几十GB、几百GB、乃至几TB的海量存储，再以通常的文件处理方法进行处理显然是行不通的。目前，对于上述这种大文件的操作一般是以内存映射文件的方式来加以处理的，本文下面将针对这种Windows核心编程技术展开讨论。

　　内存映射文件概述

　　内存文件映射也是Windows的一种内存管理方法，提供了一个统一的内存管理特征，使应用程序可以通过内存指针对磁盘上的文件进行访问，其过程就如同对加载了文件的内存的访问。通过文件映射这种使磁盘文件的全部或部分内容与进程虚拟地址空间的某个区域建立映射关联的能力，可以直接对被映射的文件进行访问，而不必执行文件I/O操作也无需对文件内容进行缓冲处理。内存文件映射的这种特性是非常适合于用来管理大尺寸文件的。

　　在使用内存映射文件进行I/O处理时，系统对数据的传输按页面来进行。至于内部的所有内存页面则是由虚拟内存管理器来负责管理，由其来决定内存页面何时被分页到磁盘，哪些页面应该被释放以便为其它进程提供空闲空间，以及每个进程可以拥有超出实际分配物理内存之外的多少个页面空间等等。由于虚拟内存管理器是以一种统一的方式来处理所有磁盘I/O的（以页面为单位对内存数据进行读写），因此这种优化使其有能力以足够快的速度来处理内存操作。

　　使用内存映射文件时所进行的任何实际I/O交互都是在内存中进行并以标准的内存地址形式来访问。磁盘的周期性分页也是由操作系统在后台隐蔽实现的，对应用程序而言是完全透明的。内存映射文件的这种特性在进行大文件的磁盘事务操作时将获得很高的效益。

　　需要说明的是，在系统的正常的分页操作过程中，内存映射文件并非一成不变的，它将被定期更新。如果系统要使用的页面目前正被某个内存映射文件所占用，系统将释放此页面，如果页面数据尚未保存，系统将在释放页面之前自动完成页面数据到磁盘的写入。

　　对于使用页虚拟存储管理的Windows操作系统，内存映射文件是其内部已有的内存管理组件的一个扩充。由可执行代码页面和数据页面组成的应用程序可根据需要由操作系统来将这些页面换进或换出内存。如果内存中的某个页面不再需要，操作系统将撤消此页面原拥用者对它的控制权，并释放该页面以供其它进程使用。只有在该页面再次成为需求页面时，才会从磁盘上的可执行文件重新读入内存。同样地，当一个进程初始化启动时，内存的页面将用来存储该应用程序的静态、动态数据，一旦对它们的操作被提交，这些页面也将被备份至系统的页面文件，这与可执行文件被用来备份执行代码页面的过程是很类似的。图1展示了代码页面和数据页面在磁盘存储器上的备份过程：


图1 进程的代码页、数据页在磁盘存储器上的备份

　　显然，如果可以采取同一种方式来处理代码和数据页面，无疑将会提高程序的执行效率，而内存映射文件的使用恰恰可以满足此需求。
对大文件的管理

　　内存映射文件对象在关闭对象之前并没有必要撤销内存映射文件的所有视图。在对象被释放之前，所有的脏页面将自动写入磁盘。通过CloseHandle（）关闭内存映射文件对象，只是释放该对象，如果内存映射文件代表的是磁盘文件，那么还需要调用标准文件I/O函数来将其关闭。在处理大文件处理时，内存映射文件将表示出卓越的优势，只需要消耗极少的物理资源，对系统的影响微乎其微。下面先给出内存映射文件的一般编程流程框图：


图2 使用内存映射文件的一般流程

　　而在某些特殊行业，经常要面对十几GB乃至几十GB容量的巨型文件，而一个32位进程所拥有的虚拟地址空间只有232 = 4GB，显然不能一次将文件映像全部映射进来。对于这种情况只能依次将大文件的各个部分映射到进程中的一个较小的地址空间。这需要对上面的一般流程进行适当的更改：

　　1）映射文件开头的映像。

　　2）对该映像进行访问。

　　3）取消此映像

　　4）映射一个从文件中的一个更深的位移开始的新映像。

　　5）重复步骤2，直到访问完全部的文件数据。

　　下面给出一段根据此描述而写出的对大于4GB的文件的处理代码：

// 选择文件 CFileDialog fileDlg(TRUE, "*.txt", "*.txt", NULL, "文本文件 (*.txt)|*.txt||", this); fileDlg.m_ofn.Flags |= OFN_FILEMUSTEXIST; fileDlg.m_ofn.lpstrTitle = "通过内存映射文件读取数据"; if (fileDlg.DoModal() == IDOK) { 　// 创建文件对象 　HANDLE hFile = CreateFile(fileDlg.GetPathName(), GENERIC_READ | GENERIC_WRITE, 　　　0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 　if (hFile == INVALID_HANDLE_VALUE) 　{ 　　TRACE("创建文件对象失败,错误代码:%d\r\n", GetLastError()); 　　return; 　} 　// 创建文件映射对象 　HANDLE hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL); 　if (hFileMap == NULL) 　{ 　　TRACE("创建文件映射对象失败,错误代码:%d\r\n", GetLastError()); 　　return; 　} 　// 得到系统分配粒度 　SYSTEM_INFO SysInfo; 　GetSystemInfo(&SysInfo); 　DWORD dwGran = SysInfo.dwAllocationGranularity; 　// 得到文件尺寸 　DWORD dwFileSizeHigh; 　__int64 qwFileSize = GetFileSize(hFile, &dwFileSizeHigh); 　qwFileSize |= (((__int64)dwFileSizeHigh) << 32); 　// 关闭文件对象 　CloseHandle(hFile); 　// 偏移地址 　__int64 qwFileOffset = 0; 　// 块大小 　DWORD dwBlockBytes = 1000 * dwGran; 　if (qwFileSize < 1000 * dwGran) 　　dwBlockBytes = (DWORD)qwFileSize; 　　while (qwFileOffset > 0) 　　{ 　　　// 映射视图 　　　LPBYTE lpbMapAddress = (LPBYTE)MapViewOfFile(hFileMap,FILE_MAP_ALL_ACCESS, 　　　　　　(DWORD)(qwFileOffset >> 32), (DWORD)(qwFileOffset & 0xFFFFFFFF), 　　　　　　dwBlockBytes); 　　　if (lpbMapAddress == NULL) 　　　{ 　　　　TRACE("映射文件映射失败,错误代码:%d\r\n", GetLastError()); 　　　　return; 　　　} 　　　// 对映射的视图进行访问 　　　for(DWORD i = 0; i < dwBlockBytes; i++) 　　　　BYTE temp = *(lpbMapAddress + i); 　　　　// 撤消文件映像 　　　　UnmapViewOfFile(lpbMapAddress); 　　　　// 修正参数 　　　　qwFileOffset += dwBlockBytes; 　　　　qwFileSize -= dwBlockBytes; 　　} 　　// 关闭文件映射对象句柄 　　CloseHandle(hFileMap); 　　AfxMessageBox("成功完成对文件的访问"); }

　　在本例中，首先通过GetFileSize（）得到被处理文件长度（64位）的高32位和低32位值。然后在映射过程中设定每次映射的块大小为1000倍的分配粒度，如果文件长度小于1000倍的分配粒度时则将块大小设置为文件的实际长度。在处理过程中由映射、访问、撤消映射构成了一个循环处理。其中，每处理完一个文件块后都通过关闭文件映射对象来对每个文件块进行整理。CreateFileMapping（）、MapViewOfFile（）等函数是专门用来进行内存文件映射处理用的。

　下面分别对这些关键函数进行说明：

　　1）CreateFile（）：CreateFile（）函数是一个用途非常广泛的函数， 在这里的用法并没有什么特殊的地方，但有几点需要注意：一是访问模式参数dwDesiredAccess。该参数设置了对文件内核对象的访问类型，其允许设置的权限可以为读权限GENERIC_READ、写权限GENERIC_WRITE、读写权限GENERIC_READ | GENERIC_WRITE和设备查询权限0。在使用映射文件时，只能打开那些具有可读访问权限的文件，即只能应用GENERIC_READ和GENERIC_READ | GENERIC_WRITE这两种组合；另一点需要注意的是共享模式参数dwShareMode。该参数定义了对文件内核对象的共享方式，其可能的设置为FILE_SHARE_READ、FILE_SHARE_WRITE和0，并可对其组合使用。其中，设置为0时不允许共享对象；FILE_SHARE_READ和FILE_SHARE_WRITE分别为在要求只读、只写访问的情况下才允许对象的共享。

　　由于通过内存映射文件可以在多个进程间共享数据，因此在进行这种应用时应当考虑dwShareMode参数设置对运行结果的影响。

　　2）CreateFileMapping（）：该函数的作用是创建一个文件映射内核对象，以告知系统文件映射对象需要多大的物理存储器。创建内存映射文件对象对系统资源几乎没有什么影响，也不会影响进程的虚拟地址空间。除了需要用来表示该对象的内部资源之外通常并不用为其分配虚拟内存，但是如果内存映射文件对象是作共享内存之用的话，就要在创建对象时由系统为内存映射文件的使用在系统页文件中保留足够的空间。

　　函数第一个参数hFile为标识要映射到进程的地址空间的文件的句柄。虽然由于内存映射文件的物理存储器是来自于磁盘上的文件，而非系统的页文件，使创建内存映射文件就像保留一个地址空间区域并将物理存储器提交给该区域一样。第二个参数为指向文件映射内核对象的SECURITY_ATTRIBUTES结构的指针，由此来决定子进程能否继承得到返回的句柄。通常为其传递NULL值，以默认的安全属性来禁止返回句柄的被继承。

　　接下来的参数用于文件被映射后设定文件映像的保护属性。其可能的取值为PAGE_READONLY、PAGE_READWRITE和PAGE_WRITECOPY。虽然在创建文件映射对象时，系统并不为其保留地址空间区域，也不将文件的存储器映射到该区域。但是，在系统将存储器映射到进程的地址空间中去时，系统必须确切知道应赋予物理存储器页面的保护属性。在设置保护属性时，必须与用CreateFile（）函数打开文件时所指定的访问标识相匹配，否则将导致CreateFileMapping（）的执行失败。因此这里设置PAGE_READWRITE属性。除了上述三个页面保护属性外，还有4个区（Section）保护属性也可以一起组合使用：

区保护属性	说明
SEC_COMMIT	为区中的所有页面在内存中或磁盘页面文件中分配物理存储器
SEC_IMAGE	告知系统，映射的文件是一个可移植的EXE文件映像
SEC_NOCACHE	告知系统，未将文件的任何内存映射文件放入高速缓存，多供硬件设备驱动程序开发人员使用
SEC_RESERVE	对一个区的所有页面进行保留而不分配物理存储器

　　后面的两个参数指定了要创建的文件映射对象的最大字节数的高32位值和低32位值，实际也就设定了文件的最大字节数（最大可以处理16EB的文件）。这两个参数可以满足确保文件映射对象能够得到足够的物理存储器这一基本条件。在参数设置的大小小于文件实际大小时，系统将从文件映射指定的字节数。这里将其设置为0，将使所创建的文件映射对象将为文件的当前大小，以上两种情况均无法改变文件的大小。如果设置的参数大于文件的实际大小，系统将会在CreateFileMapping（）函数返回前扩展该文件。需要指出的是，文件映射对象的大小是静态的，一旦创建完毕后将无法更改。如果设置的文件映射对象尺寸偏小将导致无法对文件进行全面的访问。

　　在本节开始也曾提到过，创建文件映射对象是不需要花费什么系统资源的，因此遵循"宁多勿缺"的原则，一般应将文件映射对象的大小设置为文件大小的相同值。函数最后的参数将可以为映射对象命名。如果想打开一个已存在的文件映射对象，该对象必须要命名。对该名字字符串的要求仅限于未被其它对象使用过的名字即可。

　　CreateFileMapping（）在成功执行后将返回一个指向文件映射对象的句柄。如果对一个已经存在的文件映射对象调用了CreateFileMapping（）函数，进程将得到一个指向现有映射对象的句柄。通过调用GetLastError（）可以得到返回值ERROR_ALREADY_EXIST，由此可以判断当前得到的内存映射对象句柄是新创建的还是打开已经存在的。如果系统无法创建文件映射对象，将导致CreateFileMapping（）的执行失败，返回N U L L句柄值。

3）MapViewOfFile（）：当创建了一个内存映射文件对象并得到其有效句柄后，该句柄即可用来在进程的虚拟地址空间中映射文件的一个映像。在内存映射文件对象已经存在的情况下，映像可被任意映射或取消映射。在文件映像被映射时，仍然必须由系统来为文件的数据保留一个地址空间区域，并将文件的数据作为映射到该区域的物理存储器进行提交。在进程的地址空间中，一个足够大的连续地址空间（通常足以覆盖整个文件映像）将被指定给此文件映像。尽管如此，内存的物理页面还是根据在实际使用中的需求而进行分配的。真正分配一个对应于内存映射文件映像页面的物理内存页面是在发生该页的缺页中断时进行的，这将在第一次读写内存页面中的任一地址时自动完成。MapViewOfFile（）即负责映射内存映射文件的一个映像，

　　函数的第一个参数为CreateFileMapping（）所返回的内存映射文件对象句柄，第二个参数指定了对文件映像的访问类型，可能取值有FILE_MAP_WRITE、FILE_MAP_READ、FILE_MAP_ALL_ACCESS和FILE_MAP_COPY等几种，具体的设置要根据文件映射对象允许的保护模式而定。根据前面代码的设置，这里应该使用FILE_MAP_ALL_ACCESS参数。这种机制为对象的创建者提供了对映射此对象的方式进行控制的能力。接下来的2个参数分别指定了内存映射文件的64位偏移地址的低32位和高32位地址，该地址是从内存映射文件头位置到映像开始位置的距离。最后的参数指定了视图的大小，如果设置为0，前面的偏移地址将被忽略，系统将会把整个文件映射为一个映像。MapViewOfFile（）如果成功执行，将返回一个指向文件映像在进程的地址空间中的起始地址的指针。如果失败，则返回NULL。在进程中，可以为同一个文件映射对象创建多个文件映像，这些映像可以在系统中共存和重叠，也可以与对应的文件映射对象大小不相一致，但不能大于文件映射对象的大小。

　　4）UnmapViewOfFile（）：当不再需要保留映射到进程地址空间区域中的文件映像数据时，可通过调用UnmapViewOfFile（）函数将其释放。该函数结构非常简单，只需要提供映像在进程中的起始地址（区域的基地址）作为参数即可。该函数的输入参数为调用MapViewOfFile（）时所返回的指向文件映像在进程的地址空间中的起始地址的指针。在调用MapViewOfFile（）后，必须确保在进程退出之前能够执行UnmapViewOfFile（）函数，否则在进程终止之后先前保留的区域将得不到释放，即使再次启动进程重复调用MapViewOfFile（）系统也总是在进程的地址空间中保留一个新的区域，而此前保留的所有区域将得不到释放。

　　一种比较特殊的情况是，对同一个内存映射文件映射了两个相同的映像的撤消。前面曾经提到过，对于同一个内存映射文件可以有多个映像，这些映像也可以重叠，因此这种情况的存在是合法的。对于这种情况，虽然从表面看上去在单进程的地址空间内是不可能存在两个基地址完全相同的映像的，这将导致无法对这它们的区分。但是事实上，由MapViewOfFile（）所返回得到的基地址只是文件映像在进程地址空间中的起始基地址，因此在映射同一内存映射文件的两个相同映像时将会产生对内存映射文件同一部分的两个不同基地址的相同映像，可以用同样的方法调用UnmapViewOfFile（）将其从进程的地址空间中予以撤消。

　　5）CloseHandle（）： 与Win32的大多数对象一样，在使用完毕之后总是要通过CloseHandle（）函数将已打开的内核对象关闭。如果忘记关闭对象，在程序继续运行时将会出现资源泄漏。虽然在程序退出运行时，操作系统会自动关闭在进程中已经打开但未关闭的任何对象。但是在进程的运行过程中，势必会积累过多的资源句柄。因此在不再需要使用对象的时候通过CloseHandle（）将其予以关闭是有意义的。

　　小结

　　本文对内存映射文件在大文件处理中的应用作了较为详细的阐述。经实际测试，内存映射文件在处理大数据量文件时表现出了良好的性能，比通常使用CFile类和ReadFile()和WriteFile()等函数的文件处理方式具有明显的优势。本文所述程序代码在Windows 2000 Professional下由Microsoft Visual C++ 6.0编译通过。

 

今天的任务是要保存一个文件。平常看别人怎么写，自己还只是看，没有动手去写过，对各个API相应的参数不是很了解。今天在运用的时候，还真是遇见了一些问题。

我们先来说说问题：
第一个问题：使用WriteFile的时候，我直接将宽字符串写进了文件，文件显示如大家所想，掺杂了很多乱码。但是很有规则。所以我很快就明白了这需要将宽字符串转换成ASCII码。
第二个问题：就是我将文件打开后，又进行了写文件的操作，此时失败。所以对这种情况，还没有想出办法，是由于CreateFile的参数的某些限制么？

由于这两个问题，所以我也好好看了一下SDK文档。
我们先来看一下CreateFile和WriteFile的原型和参数介绍：

HANDLE CreateFile(
  LPCTSTR lpFileName,  // 文件名
  DWORD dwDesiredAccess,  // 访问方式
  DWORD dwShareMode,  // 共享模式
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,  // 设为NULL
  DWORD dwCreationDisposition,  /// 创建方式
  DWORD dwFlagsAndAttributes,  // 属性
  HANDLE hTemplateFile
);

BOOL WriteFile(

 HANDLE hFile, // 文件句柄

 LPCVOID lpBuffer, // 包含写向文件的数据

 DWORD nNumberOfBytesToWrite, // 数据包含的字符串的个数

 LPDWORD lpNumberOfBytesWritten,

 LPOVERLAPPED lpOverlapped

);

第一次我写的程序很简单

BOOL WriteOwnFile(TCHAR* pFileName, TCHAR* pBuffer, DWORD dwLen)

{

        HANDLE hFile = CreateFile(pFileName,

                       GENERIC_WRITE,

                                              FILE_SHARE_WRITE,

                                              NULL,

                                              CREATE_ALWAYS,

                                              FILE_ATTRIBUTE_NORMAL,

                                              NULL

                                              ）；

 

                 if (INVALID_HANDLE_VALUE != hFile)

               {

                                              DWORD dwSize = 0;

                                              WriteFile(hFile, pBuffer, dwLen, &dwSize, NULL );

                                              CloseHandle(hFile);

                                              return TRUE;

               }

               return FALSE;

}

 

这样是完成了，但是写出来的文件是乱码。所以没有进行字符的转换，我们需要将pBuffer进行转换。这就要用到了WideCharToMultiByte.如何用呢？

首先我的方法比较笨，我是这么用的：

char* pchBuffer = new char[dwLen+1];

WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, pchBuffer, dwLen+1, NULL, FALSE );

WriteFile(hFile, pBuffer, dwLen+1, &dwSize, NULL );

 Delete[] pchBuffer;

 

此时注意，我在WriteFile中用了dwLen+1。结果就是在文件的末尾出现了乱码，正好多一个乱码出来。所以WriteFile中nNumberOfBytesToWrite是写的字符串的数目，是不包括’\0’的。

 

这个方法笨，是因为我们的函数可以缩减为两个参数。是因为如下这么写时，dwLen是所要转换的字符串的个数，此时转换的字符串是包括’\0’的。

DWORD dwLen = WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, NULL, NULL, NULL, FALSE );

 

所以我们再来看一下改写以后的代码

BOOL WriteOwnFile(TCHAR* pFileName, TCHAR* pBuffer)

{

        HANDLE hFile = CreateFile(pFileName,

                       GENERIC_WRITE,

                                              FILE_SHARE_WRITE,

                                              NULL,

                                              CREATE_ALWAYS,

                                              FILE_ATTRIBUTE_NORMAL,

                                              NULL

                                              ）；

 

                               if (INVALID_HANDLE_VALUE != hFile)

               {

                                              DWORD dwSize = 0;

                                              DWORD dwLen = WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, NULL, NULL, NULL, FALSE );

                                              char* pchBuffer = new char[dwLen];

                                              WideCharToMultiByte(CP_ACP, NULL, pBuffer, -1, pchBuffer, dwLen, NULL, FALSE );

                                              WriteFile(hFile, pBuffer, dwLen+1, &dwSize, NULL );

                                               delete[] pchBuffer;

                                              CloseHandle(hFile);

                                              return TRUE;

               }

               return FALSE;

}

 

 

这样感觉代码好看多了。

 

对于第二个问题，文件打开的时候文件创建失败，还没有想好办法解决。我在想是不是我的某些认知存在问题，文件打开的时候，是否可以用CreateFile来打开呢？

今天完成了一个任务,就是在mobile上如何监控文件的操作。这个SDK中有相应的例子，为FileChangeNotif。

 如何实现文件监控？
         首先要在窗口注册，这个要用到SHChangeNotifyRegister，这个函数的主要功能就是列举一个窗口来接收change notifications.
         在这个注册的窗口中，响应WM_FILECHANGEINFO这个消息，来进行我们响应的操作。
         如何我们不想监控了，则可以使用SHChangeNotifyDeregister，来移除相应的注册窗口。

这样我们就可以实现对一个文件夹内文件的生成，删除，改名等等操作的监控。

下面我们再具体来谈谈每一步如何操作。
1、SHChangeNotifyRegister的运用
   SHChangeNotifyRegister的原型为
  BOOL WINAPI SHChangeNotifyRegister(

HWND hwnd,

SHCHANGENOTIFYENTRY * pshcne

);

  其中,hwnd,为接收change notification的窗口;

pshcne是一个指向SHCHANGENOTIFYENTRY结构的指针,它用来指明窗口接收的change notification的类型.如果设为NULL,窗口将接收all file system, network 和 media类型的notifications.

SHCHANGENOTIFYENTRY是什么样的一个结构,我们看一下它的定义

typedef  struct  tagSHCHANGENOTIFYENTRY {

   DWORD dwEventMask;

   LPTSTR pszWatchDir;

 BOOL fRecursive;

} SHCHANGENOTIFYENTRY;

dwEventMask 指定发生什么时间来发送notification 消息

pszWatchDir 指定监控路径，该值为NULL的情况下，是监控所有的文件。

fRecursive指定是否只监控指定路径还是监控指定路径及其子文件夹。

 

知道了这些，我们不妨写一个这样的函数，来启动文件监控。

代码如下：

2、如何处理WM_FILECHANGEINFO消息

WM_FILECHANGEINFO 中的参数lParam，指向FILECHANGENOTIFY，含有相关的数据。所以我们在收到该消息后，先作的一部操作就是

FILECHANGENOTIFY *lpfcn = (FILECHANGENOTIFY*)lParam;

FILECHANGENOTIFY的结构为：

typedef struct tagFILECHANGENOTIFY {

 DWORD dwRefCount;

 FILECHANGEINFO fci;

} FILECHANGENOTIFY;

我们主要用到了其中的fci参数。

FILECHANGEINFO的结构为：

struct _FILECHANGEINFO {

 DWORD cbSize;

 LONG wEventId;

 ULONG uFlags;

 DWORD dwItem1;

 DWORD dwItem2;

 DWORD dwAttributes;

 FILETIME ftModified;

 ULONG nFileSize;

} FILECHANGEINFO, *LPFILECHANGEINFO;

dwEventId 与SHCHANGENOTIFYENTRY结构中的dwEventMask对应。

dwItem1,dwItem2是事件依赖的值，里面包括了我们需要的文件的完整路径。如果是进行创建文件的操作，则dwItem1是创建后文件的完整路径，如果是对文件进行重新命名操作的话，则dwItem2是修改后文件的完整路径。此处对其他参数不做介绍，大家需要的话，可以查看一下。

 

我们做完相应的操作后，要知道释放，此时要用到SHChangeNotifyFree。这个用起来就简单很多，如SHChangeNotifyFree（lpfcn）。

 

下面给大家一小段示例代码，如下

 

3、如何停止文件监控

   停止文件监控比较简单，只要使该窗口不接收WM_FILECHANGEINFO消息即可。使用SHChangeNotifyDeregister(hWnd)即可。

 

以上是我今天学习的一些总结，此外需要注意的一个小地方，在mobile上，把一个文件从一个文件夹拷到另一个文件夹，此时响应的事件是SHCNE_CREATE，二从电脑上拷贝一个文件到mobile上，响应的消息为SHCNE_RENAME。我注意到从电脑上拷贝的话，mobile会先生成一个Temp文件夹内生成一个临时文件，然后再在我们指定的文件夹内生成一个文件。这个机制我还不是很清楚为什么。

今天在加数据库的相关操作时,遇到了一些问题,提示

error C3861: 'CeMountDBVolEx': identifier not found
error C3861: 'CeMountDBVolEx': identifier not found
error C3861: 'CeCreateDatabaseWithProps': identifier not found
error C3861: 'CeCreateSession': identifier not found
error C3861: 'CeOpenDatabaseInSession': identifier not found

我在.cpp文件的开头加入了

#define EDB
#include <windows.h>
#include <windbase.h>

但是错误还依然存在

从网上搜索了一些方法

在博文《mobile数据库遇到的问题》

http://blog.sina.com.cn/s/blog_4c5ad0740100cvxg.html

它里面建议使用

extern "C"
{
  #include <windbase_edb.h>
}

但是使用后，问题变成了lnk的错误

error LNK2019: unresolved external symbol

有人在论坛里建议

#include Windbase_edb.h

也是同样的问题

最后，我问了一下我的同事

他建议我在

stdafx.h 头文件中添加

#define EDB
#include <windows.h>
#include <windbase.h>

这样的确解决了问题。

先粘过来,备以后细读
链接地址:http://www.bsdlover.cn/index.php?action/viewnews/itemid/1611/page/1/php/1

进程间通信有以下方法
Using named objects
Waiting for multiple objects
Waiting in a message loop
Using mutex objects
Using semaphore objects
Using event objects
Using critical section objects
Using timer queues
Using waitable timer objects
 进程间的通讯实现（IPC）的11种方法   

进程通常被定义为一个正在运行的程序的实例，它由两个部分组成：
一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方
 另一个是地址空间，它包含所有的可执行模块或DLL模块的代码和数据。它还包含动态分配的空间。如线程堆栈和堆分配空间。每个进程被赋予它自己的虚拟地址空间，当进程中的一个线程正在运行时，该线程可以访问只属于它的进程的内存。属于其它进程的内存则是隐藏的，并不能被正在运行的线程访问。
   为了能在两个进程之间进行通讯，由以下几种方法可供参考：

在16位时代常使用的方式，CWnd中提供支持
1。窗口消息 标准的Windows消息以及专用的WM_COPYDATA消息 SENDMESSAGE()接收端必须有一个窗口

2。使用共享内存方式（Shared Memory)
a.设定一块共享内存区域       
     HANDLE CreateFileMapping(HANDLE,LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD,  LPCSTR)
     产生一个file-mapping核心对象
     LPVOID MapViewOfFile(
         HANDLE hFileMappingObject,
        DWORD  dwDesiredAcess,
         DWORD  dwFileOffsetHigh,
         DWORD  dwFileOffsetLow,
          DWORD  dwNumberOfBytesToMap
     );
得到共享内存的指针
   b.找出共享内存
    决定这块内存要以点对点（peer to peer)的形式呈现
每个进程都必须有相同的能力，产生共享内存并将它初始化。每个进程
都应该调用CreateFileMapping(),然后调用GetLastError().如果传回的错误代码是ERROR_ALREADY_EXISTS,那么进程就可以假设这一共享内存区         域已经被别的进程打开并初始化了，否则该进程就可以合理的认为自己 排在第一位，并接下来将共享内存初始化。还是要使用client/server架构中只有server进程才应该产生并初始化共享内存。所有的进程都应该使用
HANDLE OpenFileMapping(DWORD dwDesiredAccess,
                                   BOOL bInheritHandle,
                                   LPCTSTR lpName);
        再调用MapViewOfFile(),取得共享内存的指针
   c.同步处理(Mutex)
   d.清理(Cleaning up) BOOL UnmapViewOfFile(LPCVOID lpBaseAddress);
    CloseHandle()

3。动态数据交换（DDE）通过维护全局分配内存使的应用程序间传递成为可能
   其方式是再一块全局内存中手工放置大量的数据，然后使用窗口消息传递内存    指针.这是16位WIN时代使用的方式，因为在WIN32下已经没有全局和局部内存    了，现在的内存只有一种就是虚存。  

4。消息管道(Message Pipe)
   用于设置应用程序间的一条永久通讯通道，通过该通道可以象自己的应用程序
   访问一个平面文件一样读写数据。
   名管道(Anonymous Pipes)
    单向流动，并且只能够在同一电脑上的各个进程之间流动。
   命名管道(Named Pipes)
   双向，跨网络，任何进程都可以轻易的抓住，放进管道的数据有固定的格式，而使用ReadFile()只能读取该大小的倍数。可以被使用于I/O Completion Ports

5邮件槽(Mailslots)
    广播式通信,在32系统中提供的新方法，可以在不同主机间交换数据，在        WIN9X下只支持邮件槽客户

6Windows套接字(Windows Socket)
   它具备消息管道所有的功能，但遵守一套通信标准使的不同操作系统之上的应    用程序之间可以互相通信。

7Internet通信 它让应用程序从Internet地址上载或下载文件

8。RPC：远程过程调用，很少使用，因其与UNIX的RPC不兼容。

9。串行/并行通信(Serial/Parallel Communication)
   它允许应用程序通过串行或并行端口与其他的应用程序通信

10。COM/DCOM
     通过COM系统的代理存根方式进行进程间数据交换，但只能够表现在对接口     函数的调用时传送数据，通过DCOM可以在不同主机间传送数据。

今天在与同事讨论如何进行进程间的通讯,在网上查找了一些内容,贴出来以备查找.

链接地址:
http://www.cnblogs.com/henryzc/archive/2005/11/08/271920.html

1、引言
　　在Windows程序中，各个进程之间常常需要交换数据，进行数据通讯。WIN32 API提供了许多函数使我们能够方便高效的进行进程间的通讯，通过这些函数我们可以控制不同进程间的数据交换，就如同在WIN16中对本地进程进行读写操作一样。
　　典型的WIN16两进程可以通过共享内存来进行数据交换：（1）进程A将GlobalAlloc（GMEM_SHARE...）API分配一定长度的内存；（2）进程A将GlobalAlloc函数返回的句柄传递给进程B（通过一个登录消息）；（3）进程B对这个句柄调用GlobalLock函数，并利用GlobalLock函数返回的指针访问数据。这种方法在WIN32中可能失败，这是因为GlobalLock函数返回指向的是进程A的内存，由于进程使用的是虚拟地址而非实际物理地址，因此这一指针仅与A进程有关，而于B进程无关。
　　本文探讨了几种WIN32下进程之间通讯的几种实现方法，读者可以使用不同的方法以达到程序运行高效可靠的目的。

2、Windows95中进程的内存空间管理
　　WIN32进程间通讯与Windows95的内存管理有密切关系，理解Windows95的内存管理对我们如下的程序设计将会有很大的帮助，下面我们讨论以下Windows95中进程的内存空间管理。
　　在WIN16下，所有Windows应用程序共享单一地址，任何进程都能够对这一空间中属于共享单一的地址空间，任何进程都能够对这一空间中属于其他进程的内存进行读写操作，甚至可以存取操作系统本身的数据，这样就可能破坏其他程序的数据段代码。
　　在WIN32下，每个进程都有自己的地址空间，一个WIN32进程不能存取另一个地址的私有数据，两个进程可以用具有相同值的指针寻址，但所读写的只是它们各自的数据，这样就减少了进程之间的相互干扰。另一方面，每个WIN32进程拥有4GB的地址空间，但并不代表它真正拥有4GB的实际物理内存，而只是操作系统利用CPU的内存分配功能提供的虚拟地址空间。在一般情况下，绝大多数虚拟地址并没有物理内存于它对应，在真正可以使用这些地址空间之前，还要由操作系统提供实际的物理内存（这个过程叫"提交"commit）。在不同的情况下，系统提交的物理内存是不同的，可能是RAM，也可能是硬盘模拟的虚拟内存。

3、WIN32中进程间的通讯
　　在Windows 95中，为实现进程间平等的数据交换，用户可以有如下几种选择：
　　* 使用内存映射文件
　　* 通过共享内存DLL共享内存
　　* 向另一进程发送WM_COPYDATA消息
　　* 调用ReadProcessMemory以及WriteProcessMemory函数，用户可以发送由GlobalLock(GMEM_SHARE,...)函数调用提取的句柄、GlobalLock函数返回的指针以及VirtualAlloc函数返回的指针。

3.1、利用内存映射文件实现WIN32进程间的通讯
　　Windows95中的内存映射文件的机制为我们高效地操作文件提供了一种途径，它允许我们在WIN32进程中保留一段内存区域，把目标文件映射到这段虚拟内存中。在程序实现中必须考虑各进程之间的同步。具体实现步骤如下：
首先我们在发送数据的进程中需要通过调用内存映射API函数CreateFileMapping创建一个有名的共享内存：
HANDLE CreateFileMapping(
HANDLE hFile, // 映射文件的句柄，
//设为0xFFFFFFFF以创建一个进程间共享的对象
LPSECURITY_ATTRIBUTES lpFileMappingAttributes, // 安全属性
DWORD flProtect, // 保护方式
DWORD dwMaximumSizeHigh, //对象的大小
DWORD dwMaximumSizeLow,
LPCTSTR lpName // 必须为映射文件命名
);

　　与虚拟内存类似，保护方式可以是PAGE_READONLY或是PAGE_READWRITE。如果多进程都对同一共享内存进行写访问，则必须保持相互间同步。映射文件还可以指定PAGE_WRITECOPY标志，可以保证其原始数据不会遭到破坏，同时允许其他进程在必要时自由的操作数据的拷贝。
　　在创建文件映射对象后使用可以调用MapViewOfFile函数映射到本进程的地址空间内。
　　下面说明创建一个名为MySharedMem的长度为4096字节的有名映射文件：
　　HANDLE hMySharedMapFile=CreateFileMapping((HANDLE)0xFFFFFFFF)，
　　NULL，PAGE_READWRITE，0，0x1000，"MySharedMem")；
　　并映射缓存区视图：
　　LPSTR pszMySharedMapView=(LPSTR)MapViewOfFile(hMySharedMapFile，
　　FILE_MAP_READ|FILE_MAP_WRITE，0，0，0);

　　其他进程访问共享对象，需要获得对象名并调用OpenFileMapping函数。
　　HANDLE hMySharedMapFile=OpenFileMapping(FILE_MAP_WRITE，
　　FALSE，"MySharedMem");

　　一旦其他进程获得映射对象的句柄，可以象创建进程那样调用MapViewOfFile函数来映射对象视图。用户可以使用该对象视图来进行数据读写操作，以达到数据通讯的目的。

　　当用户进程结束使用共享内存后，调用UnmapViewOfFile函数以取消其地址空间内的视图：
if (!UnmapViewOfFile(pszMySharedMapView))
{ AfxMessageBox("could not unmap view of file"); }

3.2、利用共享内存DLL
　　共享数据DLL允许进程以类似于Windows 3.1 DLL共享数据的方式访问读写数据，多个进程都可以对该共享数据DLL进行数据操作，达到共享数据的目的。在WIN32中为建立共享内存，必须执行以下步骤：
　　首先创建一个有名的数据区。这在Visual C++中是使用data_seg pragma宏。使用data_seg pragma宏必须注意数据的初始化：
#pragma data_seg("MYSEC")
char MySharedData[4096]={0};
#pragma data_seg()
然后在用户的DEF文件中为有名的数据区设定共享属性。
LIBRARY TEST
DATA READ WRITE
SECTIONS
.MYSEC READ WRITE SHARED

　　这样每个附属于DLL的进程都将接受到属于自己的数据拷贝，一个进程的数据变化并不会反映到其他进程的数据中。

　　在DEF文件中适当地输出数据。以下的DEF文件项说明了如何以常数变量的形式输出MySharedData。
EXPORTS
MySharedData CONSTANT
最后在应用程序（进程）按外部变量引用共享数据。
extern _export"C"{char * MySharedData[];}
进程中使用该变量应注意间接引用。
m_pStatic=(CEdit*)GetDlgItem(IDC_SHARED);
m_pStatic->GetLine(0,*MySharedData,80);
3.3、用于传输只读数据的WM_COPYDATA
　　传输只读数据可以使用Win32中的WM_COPYDATA消息。该消息的主要目的是允许在进程间传递只读数据。　　　　　Windows95在通过WM_COPYDATA消息传递期间，不提供继承同步方式。SDK文档推荐用户使用SendMessage函数，接受方在数据拷贝完成前不返回，这样发送方就不可能删除和修改数据：

SendMessage(hwnd,WM_COPYDATA,wParam,lParam);
其中wParam设置为包含数据的窗口的句柄。lParam指向一个COPYDATASTRUCT的结构：
typedef struct tagCOPYDATASTRUCT{
DWORD dwData;//用户定义数据
DWORD cbData;//数据大小
PVOID lpData;//指向数据的指针
}COPYDATASTRUCT;
该结构用来定义用户数据。

3.4、直接调用ReadProcessMemory和WriteProcessMemory函数实现进程间通讯
通过调用ReadProcessMemory以及WriteProcessMemory函数用户可以按类似与Windows3.1的方法实现进程间通讯，在发送进程中分配一块内存存放数据，可以调用GlobalAlloc或者VirtualAlloc函数实现：
pApp->m_hGlobalHandle=GlobalAlloc(GMEM_SHARE,1024);
可以得到指针地址：
pApp->mpszGlobalHandlePtr=(LPSTR)GlobalLock
(pApp->m_hGlobalHandle);
在接收进程中要用到用户希望影响的进程的打开句柄。为了读写另一进程，应按如下方式调用OpenProcess函数：
HANDLE hTargetProcess=OpenProcess(
STANDARD_RIGHTS_REQUIRED|
PROCESS_VM_REDA|
PROCESS_VM_WRITE|
PROCESS_VM_OPERATION,//访问权限
FALSE,//继承关系
dwProcessID);//进程ID
为保证OpenProcess函数调用成功，用户所影响的进程必须由上述标志创建。
一旦用户获得一个进程的有效句柄，就可以调用ReadProcessMemory函数读取该进程的内存：
BOOL ReadProcessMemory(
HANDLE hProcess, // 进程指针
LPCVOID lpBaseAddress, // 数据块的首地址
LPVOID lpBuffer, // 读取数据所需缓冲区
DWORD cbRead, // 要读取的字节数
LPDWORD lpNumberOfBytesRead
);
使用同样的句柄也可以写入该进程的内存：
BOOL WriteProcessMemory(
HANDLE hProcess, // 进程指针
LPVOID lpBaseAddress, // 要写入的首地址
LPVOID lpBuffer, // 缓冲区地址
DWORD cbWrite, // 要写的字节数
LPDWORD lpNumberOfBytesWritten
);
如下所示是读写另一进程的共享内存中的数据：
ReadProcessMemory((HANDLE)hTargetProcess,
(LPSTR)lpsz,m_strGlobal.GetBuffer(_MAX_FIELD),
_MAX_FIELD,&cb);
WriteProcessMemory((HANDLE)hTargetProcess,
(LPSTR)lpsz,(LPSTR)STARS,
m_strGlobal.GetLength(),&cb);

4、进程之间的消息发送与接收
　　在实际应用中进程之间需要发送和接收Windows消息来通知进程间相互通讯，发送方发送通讯的消息以通知接收方，接收方在收到发送方的消息后就可以对内存进行读写操作。
　　我们在程序设计中采用Windows注册消息进行消息传递，首先在发送进程初始化过程中进行消息注册：
m_nMsgMapped=::RegisterWindowsMessage("Mapped");
m_nMsgHandle=::RegisterWindowsMessage("Handle");
m_nMsgShared=::RegisterWindowsMessage("Shared");
在程序运行中向接收进程发送消息：
CWnd* pWndRecv=FindWindow(lpClassName,"Receive");
pWndRecv->SendMessage(m_MsgMapped,0,0);
pWndRecv->SendMessage(m_nMsgHandle,
(UINT)GetCurrentProcessID(),(LONG)pApp->m_hGlobalHandle);
pWndRecv->SendMessage(m_nMsgShared,0,0);
可以按如下方式发送WM_COPYDATA消息：
static COPYDATASTRUCT cds;//用户存放数据
pWnd->SendMessage(WM_COPYDATA,NULL,(LONG)&cds);

接收方进程初始化也必须进行消息注册：

UNIT CRecvApp:: m_nMsgMapped=::RegisterWindowsMessage("Mapped");
UNIT CRecvApp::m_nMsgHandle=::RegisterWindowsMessage("Handle");
UNIT CRecvApp::m_nMsgShared=::RegisterWindowsMessage("Shared");
同时映射消息函数如下：
ON_REGISTERED_MASSAGE(CRecvApp::m_nMsgMapped,OnRegMsgMapped)
ON_REGISTERED_MASSAGE(CRecvApp::m_nMsgHandle,OnRegMsgHandle)
ON_REGISTERED_MASSAGE(CRecvApp::m_nMsgShared,OnRegMsgShared)
在这些消息函数我们就可以采用上述技术实现接收进程中数据的读写操作了。

5、结束语

　　从以上分析中我们可以看出Windows95的内存管理与Windows 3.x相比有很多的不同，对进程之间的通讯有较为严格的限制。这就确保了任何故障程序无法意外地写入用户的地址空间，而用户则可根据实际情况灵活地进行进程间的数据通讯，从这一点上来讲Windows95增强应用程序的强壮性。

参考文献：

1、 David J.Kruglinski, Visual C++技术内幕, 北京：清华大学出版社，1995.
2、 Microsoft Co. Visual C++ 5.0 On Line Help.