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

对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();