一则简单的Windows共享内存IPC代码

Windows共享内存可以让两个进程对同一块内存进行读写。

以下有2个进程，a.cpp生成A进程，b.cpp生成b进程。那么a进程将不停地读名为"Global\\MyFileMappingObject"的共享内存块，而b进程不停地写名为"Global\\MyFileMappingObject"的共享内存块。从而实现IPC。

//a.cpp
#include <windows.h>
#include <string.h>
#include <string>
#include <iostream>
#include <tchar.h>
using namespace std;

#define BUF_SIZE 256
TCHAR szName[]=TEXT("Global\\MyFileMappingObject");    //指向同一块共享内存的名字

int main(int argc, char *argv[])
{
    HANDLE hMapFile;
    LPCTSTR pBuf;

    hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,    // use paging file
        NULL,                    // default security
        PAGE_READWRITE,          // read/write access
        0,                       // maximum object size (high-order DWORD)
        BUF_SIZE,                // maximum object size (low-order DWORD)
        szName);                 // name of mapping object

    if (hMapFile == NULL)
    {
        _tprintf(TEXT("Could not create file mapping object (%d).\n"),
            GetLastError());
        return 1;
    }
    pBuf = (LPTSTR) MapViewOfFile(hMapFile,   // handle to map object
        FILE_MAP_ALL_ACCESS, // read/write permission
        0,
        0,
        BUF_SIZE);

    if (pBuf == NULL)
    {
        _tprintf(TEXT("Could not map view of file (%d).\n"),
            GetLastError());

        CloseHandle(hMapFile);

        return 1;
    }
    //从main开始至此，A B process代码一样，都是获取名为"Global\\MyFileMappingObject"的共享内存的指针

    //以下代码，A不停地读共享内存pBuf
    while(1)
    {
        cout<<pBuf<<endl;
        cout<<"A process: hit keyboard to receive from B process"<<endl;
        getchar();
    }

    UnmapViewOfFile(pBuf);
    CloseHandle(hMapFile);
    return 0;
}

//b.cpp
#include <iostream>
#include <Windows.h>
#include <tchar.h>
using namespace std;

#define BUF_SIZE 256
TCHAR szName[]=TEXT("Global\\MyFileMappingObject");    //指向同一块共享内存的名字

int main()
{
    HANDLE hMapFile;
    LPCTSTR pBuf;

    hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,    // use paging file
        NULL,                    // default security
        PAGE_READWRITE,          // read/write access
        0,                       // maximum object size (high-order DWORD)
        BUF_SIZE,                // maximum object size (low-order DWORD)
        szName);                 // name of mapping object

    if (hMapFile == NULL)
    {
        _tprintf(TEXT("Could not create file mapping object (%d).\n"),
            GetLastError());
        return 1;
    }
    pBuf = (LPTSTR) MapViewOfFile(hMapFile,   // handle to map object
        FILE_MAP_ALL_ACCESS, // read/write permission
        0,
        0,
        BUF_SIZE);

    if (pBuf == NULL)
    {
        _tprintf(TEXT("Could not map view of file (%d).\n"),
            GetLastError());

        CloseHandle(hMapFile);

        return 1;
    }
    //从main开始至此，A B process代码一样，都是获取名为"Global\\MyFileMappingObject"的共享内存的指针

    //以下代码，B不停写共享内存pBuf
    while(1)
    {
        TCHAR s[BUF_SIZE];
        cout<<"B process: plz input sth. to be transfered to A process."<<endl;
        cin>>s;
        memcpy((PVOID)pBuf, s, BUF_SIZE);
    }
}

http://www.cnblogs.com/lihaozy/archive/2012/08/14/2638009.html

内存映射文件进程间共享内存

内存映射文件的另一个功能是在进程间共享数据，它提供了不同进程共享内存的一个有效且简单的方法。后面的许多例子都要用到共享内存。
共享内存主要是通过映射机制实现的。
Windows 下进程的地址空间在逻辑上是相互隔离的，但在物理上却是重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。当调用CreateFileMapping 创建命名的内存映射文件对象时，Windows 即在物理内存申请一块指定大小的内存区域，返回文件映射对象的句柄hMap。为了能够访问这块内存区域必须调用MapViewOfFile 函数，促使Windows 将此内存空间映射到进程的地址空间中。当在其他进程访问这块内存区域时，则必须使用OpenFileMapping 函数取得对象句柄hMap，并调用MapViewOfFile 函数得到此内存空间的一个映射。这样一来，系统就把同一块内存区域映射到了不同进程的地址空间中，从而达到共享内存的目的。
下面举例说明如何将内存映射文件用于共享内存。

第一次运行这个例子时，它创建了共享内存，并写入数据“123456”。只要创建共享内存的进程没有关闭句柄hMap，以后运行的程序就会读出共享内存里面的数据，并打印出来。这就是使用共享内存在进程间通信的过程。程序代码如下。

    #include <Windows.h>  
    #include <stdlib.h>  
    #include <stdio.h>  
    void main() // 08ShareMem工程下  
    {   
        char szName[] = "08ShareMem"; // 内存映射对象的名称  
        char szData[] = "123456"; // 共享内存中的数据  
        LPVOID pBuffer; // 共享内存指针  
      
        // 首先试图打开一个命名的内存映射文件对象  
        HANDLE hMap = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, 0, szName);  
        if(hMap != NULL)  
        { // 打开成功，映射对象的一个视图，得到指向共享内存的指针，显示出里面的数据  
            pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);  
            printf(" 读出共享内存数据：“%s”\n", (char*)pBuffer);  
        }  
        else  
        { // 打开失败，创建之  
            hMap = ::CreateFileMapping(  
                INVALID_HANDLE_VALUE,//无物理文件  
                NULL,  
                PAGE_READWRITE,  
                0,  
                strlen(szData) + 1,  
                "08ShareMem");//起名字  
            // 映射对象的一个视图，得到指向共享内存的指针，设置里面的数据  
            pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);  
            strcpy((char*)pBuffer, szData);  
            printf(" 写入共享内存数据：“%s”\n", (char*)pBuffer);  
        }  
        // 解除文件映射，关闭内存映射文件对象句柄  
        ::UnmapViewOfFile(pBuffer);  
        getchar(); // 注意，进程关闭后，所有句柄自动关闭，所以要在这里暂停  
        ::CloseHandle(hMap);  
        return;  
      
    }  

打开两个进程发现结果如下：

1、写入共享内存数据：  “123456”

2、读出共享内存数据：   “123456”

http://blog.youkuaiyun.com/wyyzsl212328/article/details/8482089