用文件映射（File Mapping）实现进程间内存共享

用到的几个windows API函数:

函数CreateFileMapping、MapViewOfFile声明如下： 
WINBASEAPI 
__out 
HANDLE 
WINAPI 
CreateFileMappingA( 
     __in      HANDLE hFile, 
     __in_opt LPSECURITY_ATTRIBUTES lpFileMappingAttributes, 
     __in      DWORD flProtect, 
     __in      DWORD dwMaximumSizeHigh, 
     __in      DWORD dwMaximumSizeLow, 
     __in_opt LPCSTR lpName 
     ); 
WINBASEAPI 
__out 
HANDLE 
WINAPI 
CreateFileMappingW( 
     __in      HANDLE hFile, 
     __in_opt LPSECURITY_ATTRIBUTES lpFileMappingAttributes, 
     __in      DWORD flProtect, 
     __in      DWORD dwMaximumSizeHigh, 
     __in      DWORD dwMaximumSizeLow, 
     __in_opt LPCWSTR lpName 
     ); 
#ifdef UNICODE 
#define CreateFileMapping CreateFileMappingW 
#else 
#define CreateFileMapping CreateFileMappingA 
#endif // !UNICODE 
   
WINBASEAPI 
__out 
LPVOID 
WINAPI 
MapViewOfFile( 
     __in HANDLE hFileMappingObject, 
     __in DWORD dwDesiredAccess, 
     __in DWORD dwFileOffsetHigh, 
     __in DWORD dwFileOffsetLow, 
     __in SIZE_T dwNumberOfBytesToMap 
     ); 
hFile是创建共享文件的句柄。 
lpFileMappingAttributes是文件共享的属性。 
flProtect是当文件映射时读写文件的属性。 
dwMaximumSizeHigh是文件共享的大小高位字节。 
dwMaximumSizeLow是文件共享的大小低位字节。 
lpName是共享文件对象名称。 
hFileMappingObject是共享文件对象。 
dwDesiredAccess是文件共享属性。 
dwFileOffsetHigh是文件共享区的偏移地址。 
dwFileOffsetLow是文件共享区的偏移地址。 
dwNumberOfBytesToMap是共享数据长度。 

打开已经存在的命名的文件映射，函数原型如下：
HANDLE OpenFileMapping(

    DWORD    dwDesiredAccess,

    BOOL        bInheritHandle,

    LPCTSTR  lpName);

    参数：

dwDesiredAccess: 输入参数，Mapping对象的存取权限，参见CreateFileMapping函数的flProtect参数。

bInheritHandle: 输入参数，如果设置为TRUE,则可继承进程句柄，否则不能继承。一般设置为FALSE。

返回值：

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

 取消文件映射，函数原型如下：

    BOOL UnmapViewOfFile(

        LPCVOID lpBaseAddress);

    参数lpBaseAddress为需要取消映射的内存地址。

    返回值：

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

/**********************************************************************************************************************************/

我们知道，在Windows中的每个进程都有自己独立的内存空间。该独立的内存空间包含了所有的可执行模块或DLL模块的代码和数据以及动态内存分配的空间。每个进程的内存空间只能被该进程访问，其他进程是不能访问的。
    如果我们要想在进程间共享内存（也就是创建一块不同进程都能访问的内存），那就必须使用内核对象。因为内核对象由Windows系统内核所拥有，而不是由进程所拥有。
    下面就用文件映射（File Mapping）和互斥量（Mutex）两中内核对象来实现简单的进程间内存共享。文件映射（File Mapping）用来开辟共享的内存空间，而互斥量（Mutex）则是用来使读写互斥。
    在该例子里，实现了下面5个函数用来进行进程间的内存共享。可以把这5个函数放到一个DLL里面当成输出函数来用。在进程里加载该DLL并调用相应的函数就可实现进程间内存共享。
    首先，定义返回值代码：

typedef  enum
{
    LX_OK                                 =   0 ,  //  正常返回
    LX_SHAREDMEMORY_EXISTS   =   1 ,  //  共享内存已经存在
    LX_INVALID_SHAREDMEMORY  =   2 ,  //  共享内存错误返回
    LX_INVALID_SIZE                  =   3    //  共享内存大小错误
}LX_RETURN_VALUE;

    然后，是函数声明：

//  创建共享内存
LX_RETURN_VALUE CreateSharedMemory(UINT nSize);
//  释放共享内存
LX_RETURN_VALUE ReleaseSharedMemory();
//  得到共享内存大小
LX_RETURN_VALUE GetSharedMemorySize(UINT &  nSize);
//  向共享内存写入数据
LX_RETURN_VALUE WriteToSharedMemory( void   * pData, UINT nSize);
//  从共享内存读取数据
LX_RETURN_VALUE ReadFromSharedMemory( void   * pData, UINT nSize);

    下面是函数的实现：

//  自动Lock和Unlock互斥量
struct  CAutoMutex
{
    CAutoMutex();
     ~ CAutoMutex();

     //  互斥量
     static  CMutex m_mutex;
};

CMutex CAutoMutex::m_mutex(FALSE,  " StarLeeMutex " );

CAutoMutex::CAutoMutex()
{
    m_mutex.Lock();
}

CAutoMutex:: ~ CAutoMutex()
{
    m_mutex.Unlock();
}

LX_RETURN_VALUE CreateSharedMemory(UINT nSize)
{
     //  创建共享内存块
    HANDLE hFileMapping  =  CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,  0 , nSize,  " StarLeeSharedMemory " );

     //  创建错误
     if  ((hFileMapping  ==  NULL)  ||  (hFileMapping  ==  INVALID_HANDLE_VALUE))
         return  LX_INVALID_SHAREDMEMORY;

     //  共享内存已经存在
     if  (GetLastError()  ==  ERROR_ALREADY_EXISTS)
         return  LX_SHAREDMEMORY_EXISTS;

     //  创建另外一块内存存放共享内存的大小
    HANDLE hSize  =  CreateFileMapping(NULL, NULL, PAGE_READWRITE,  0 ,  sizeof (UINT),  " StarLeeSharedMemorySize " );

     if  ((hSize  ==  NULL)  ||  (hSize  ==  INVALID_HANDLE_VALUE)  ||  (GetLastError()  ==  ERROR_ALREADY_EXISTS))
         return  LX_INVALID_SHAREDMEMORY;

     //  得到存放共享内存大小的指针
    UINT  * pSize  =  (UINT  * )MapViewOfFile(hSize, FILE_MAP_WRITE,  0 ,  0 ,  sizeof (UINT));

     if  (pSize  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

     //  写入共享内存的大小
    memcpy(pSize,  & nSize,  sizeof (UINT));

    UnmapViewOfFile(pSize);

     return  LX_OK;
}

LX_RETURN_VALUE ReleaseSharedMemory()
{
    CAutoMutex MutexLock;

     //  打开共享内存
    HANDLE hFileMapping  =  OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE,  " StarLeeSharedMemory " );

     //  关闭共享内存
     if  (hFileMapping  !=  NULL)
        CloseHandle(hFileMapping);

     //  打开存放共享内存大小的文件映射
    HANDLE hSize  =  OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE,  " StarLeeSharedMemorySize " );

     //  关闭存放共享内存大小的文件映射
     if  (hSize  !=  NULL)
        CloseHandle(hSize);

     return  LX_OK;
}

LX_RETURN_VALUE GetSharedMemorySize(UINT &  nSize)
{
    CAutoMutex MutexLock;

    HANDLE hSize  =  OpenFileMapping(FILE_MAP_READ, FALSE,  " StarLeeSharedMemorySize " );

     if  (hSize  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

    UINT  * pSize  =  (UINT  * )MapViewOfFile(hSize, FILE_MAP_READ,  0 ,  0 ,  sizeof (UINT));

     if  (pSize  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

     //  得到共享内存的大小
    memcpy( & nSize, pSize,  sizeof (UINT));

     return  LX_OK;
}

LX_RETURN_VALUE WriteToSharedMemory( void   * pDate, UINT nSize)
{
    UINT nSharedMemorySize  =   0 ;

     //  得到共享内存的大小
     if  (GetSharedMemorySize(nSharedMemorySize)  !=  LX_OK)
         return  LX_INVALID_SHAREDMEMORY;

     //  检查共享内存的大小
     if  (nSize  >  nSharedMemorySize)
         return  LX_INVALID_SIZE;

    CAutoMutex MutexLock;

    HANDLE hFileMapping  =  OpenFileMapping(FILE_MAP_WRITE, FALSE,  " StarLeeSharedMemory " );

     if  (hFileMapping  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

     void   * pMapView  =  MapViewOfFile(hFileMapping, FILE_MAP_WRITE,  0 ,  0 , nSize);

     if  (pMapView  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

     //  清空共享内存
    memset(pMapView,  0 , nSharedMemorySize);

     //  将数据写入共享内存
    memcpy(pMapView, pDate, nSize);

    UnmapViewOfFile(pMapView);

     return  LX_OK;
}

LX_RETURN_VALUE ReadFromSharedMemory( void   * pData, UINT nSize)
{
    UINT nSharedMemorySize  =   0 ;

     if  (GetSharedMemorySize(nSharedMemorySize)  !=  LX_OK)
         return  LX_INVALID_SHAREDMEMORY;

     if  (nSize  >  nSharedMemorySize)
         return  LX_INVALID_SIZE;

    CAutoMutex MutexLock;

    HANDLE hFileMapping  =  OpenFileMapping(FILE_MAP_READ, FALSE,  " StarLeeSharedMemory " );

     if  (hFileMapping  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

     void   * pMapView  =  MapViewOfFile(hFileMapping, FILE_MAP_READ,  0 ,  0 , nSize);

     if  (pMapView  ==  NULL)
         return  LX_INVALID_SHAREDMEMORY;

     //  从共享内存读取数据
    memcpy(pData, pMapView, nSize);

    UnmapViewOfFile(pMapView);

     return  LX_OK;
}

最后附记：栈是每个线程都有的，堆则是每个进程有的。