对Windows下的File Mapping一个简单的封装

#ifndef __SharedMemory_H__
#define __SharedMemory_H__


class SharedMemory
{
public:
    /// 访问模式
    enum AccessMode
    {
        AM_READ = 0,    ///< 读
        AM_WRITE        ///< 写
    };

public:
    SharedMemory(const std::string& name, std::size_t size, AccessMode mode, const void* addrHint = 0, bool server = true);
    SharedMemory(const std::string& fileName, SharedMemory::AccessMode mode, const void* addrHint = 0);
    ~SharedMemory();

public:
    /// 共享内存的起始指针
    char* begin() const;

    /// 共享内存的尾部指针
    char* end() const;

    /// 共享内存的名字
    std::string name() const;

protected:
    void map();

    void unmap();

    void close();

private:
    SharedMemory();
    SharedMemory(const SharedMemory&);
    SharedMemory& operator = (const SharedMemory&);

    std::string    m_name;
    HANDLE        m_memHandle;
    HANDLE        m_fileHandle;
    DWORD        m_size;
    DWORD        m_mode;
    char*        m_address;
};


inline char* SharedMemory::begin() const
{
    return m_address;
}

inline char* SharedMemory::end() const
{
    return m_address + m_size;
}

inline std::string SharedMemory::name() const
{ 
    return m_name; 
}


#endif

#include "stdafx.h"
#include "SharedMemory.h"

SharedMemory::SharedMemory( const std:: string& name, 
                           std::size_t size, 
                           SharedMemory::AccessMode mode, 
                            const  void* addrHint, 
                            bool)
                           : m_name(name)
                           , m_memHandle(INVALID_HANDLE_VALUE)
                           , m_fileHandle(INVALID_HANDLE_VALUE)
                           , m_size(static_cast<DWORD>(size))
                           , m_mode(PAGE_READONLY)
                           , m_address(0)
{
    if (mode == SharedMemory::AM_WRITE)
    {
        m_mode = PAGE_READWRITE;
    }

    m_memHandle = ::CreateFileMapping(INVALID_HANDLE_VALUE,
        NULL, 
        m_mode, 
        0, 
        m_size, 
        m_name.c_str());

    if (!m_memHandle)
    {
        //throw SystemException("Cannot create shared memory object", m_name);
    }

    map();
}

SharedMemory::SharedMemory(  const std:: string& fileName, AccessMode mode,  const  void* addrHint )
: m_name(fileName)
, m_memHandle(INVALID_HANDLE_VALUE)
, m_fileHandle(INVALID_HANDLE_VALUE)
, m_size(0)
, m_mode(PAGE_READONLY)
, m_address(0)
{
    DWORD shareMode = FILE_SHARE_READ;
    DWORD fileMode  = GENERIC_READ;

    if (mode == SharedMemory::AM_WRITE)
    {
        m_mode = PAGE_READWRITE;
        fileMode |= GENERIC_WRITE;
    }

    m_fileHandle = ::CreateFile(m_name.c_str(), 
        fileMode, 
        shareMode,
        NULL,
        OPEN_EXISTING, 
        FILE_ATTRIBUTE_NORMAL,
        NULL);
    if (m_fileHandle == INVALID_HANDLE_VALUE)
    {
        //throw OpenFileException("Cannot open memory mapped file", m_name);
        return;
    }

    m_size = ::GetFileSize(m_fileHandle, NULL);

    m_memHandle = ::CreateFileMapping(m_fileHandle, NULL, m_mode, 0, 0, NULL);
    if (!m_memHandle)
    {
        ::CloseHandle(m_fileHandle);
        m_fileHandle = INVALID_HANDLE_VALUE;
        //throw SystemException("Cannot map file into shared memory", m_name);
    }
    map();
}

SharedMemory::~SharedMemory()
{
    unmap();
    close();
}

void SharedMemory::map()
{
    DWORD access = FILE_MAP_READ;
    if (m_mode == PAGE_READWRITE)
    {
        access = FILE_MAP_WRITE;
    }
    LPVOID addr = ::MapViewOfFile(m_memHandle, access, 0, 0, m_size);
    if (!addr)
    {
        //throw SystemException("Cannot map shared memory object", m_name);
    }

    m_address = static_cast<char*>(addr);
}

void SharedMemory::unmap()
{
    if (m_address)
    {
        ::UnmapViewOfFile(m_address);
        m_address = 0;
        return;
    }
}

void SharedMemory::close()
{
    if (m_memHandle != INVALID_HANDLE_VALUE)
    {
        ::CloseHandle(m_memHandle);
        m_memHandle = INVALID_HANDLE_VALUE;
    }

    if (m_fileHandle != INVALID_HANDLE_VALUE)
    {
        ::CloseHandle(m_fileHandle);
        m_fileHandle = INVALID_HANDLE_VALUE;
    }
}

    LPCTSTR szFilePath = TEXT("E:\xxx.zip");
    SharedMemory sharedMemory(szFilePath, SharedMemory::AM_READ);
     char* pFileBegin = sharedMemory.begin();