簡易C\C++內存池

　　一個簡單C\C++內存池，網址如下：http://www.codeproject.com/Articles/27487/Why-to-use-memory-pool-and-how-to-implement-it，大體思路為：初始化時，分配幾十個固定大小的內存塊供程序使用，程序需要內存時，直接從內存池中取，釋放內存時，內存池回收。該程序的內存分配時這樣的，不管分配多大內存，只要內存池中有內存塊並且內存塊大小大於所需要分配的內存，就把這個內存塊分配給程序使用，但是這個內存塊剩下的內存就不能用了，所以這個內存池實現起來非常簡單。共包含兩個文件，一個頭文件和一個cpp文件。

　　MemPool.h文件：

class CMemPool
{
private:
    struct _Unit                            //鏈表結點
    {
        struct _Unit *pPrev, *pNext;
    };

    void*            m_pMemBlock;            //內存池的首地址
    struct _Unit*    m_pAllocatedMemBlock;   //指向已分配出去的內存結點
    struct _Unit*    m_pFreeMemBlock;        //指向未分配出去的內存結點
    unsigned long    m_ulUnitSize;           //內存單元個數
    unsigned long    m_ulBlockSize;          //內存單元大小
public:
    CMemPool(unsigned long lUnitNum = 50, unsigned long lUnitSize = 1024);
    ~CMemPool();
    void*           Alloc(unsigned long ulSize, bool bUseMemPool = true);   //分配內存
    void            Free( void* p );                                        //釋放內存
};

　　MemPool.cpp文件：

CMemPool::CMemPool(unsigned long ulUnitNum,unsigned long ulUnitSize) :
    m_pMemBlock(NULL), m_pAllocatedMemBlock(NULL), m_pFreeMemBlock(NULL), 
    m_ulBlockSize(ulUnitNum * (ulUnitSize+sizeof(struct _Unit))), 
    m_ulUnitSize(ulUnitSize)
{
    
    m_pMemBlock = ::malloc(m_ulBlockSize);            //申請內存
    
    if(NULL != m_pMemBlock)
    {
        for(unsigned long i=0; i<ulUnitNum; i++)    //將所有內存結點鏈接起來
        {
            struct _Unit *pCurUnit = (struct _Unit *)( (char *)m_pMemBlock + i*(ulUnitSize+sizeof(struct _Unit)) );
            
            pCurUnit->pPrev = NULL;
            pCurUnit->pNext = m_pFreeMemBlock;        
            
            if(NULL != m_pFreeMemBlock)
            {
                m_pFreeMemBlock->pPrev = pCurUnit;
            }
            m_pFreeMemBlock = pCurUnit;
        }
    }    
}

CMemPool::~CMemPool()
{
    ::free(m_pMemBlock);
}

void* CMemPool::Alloc(unsigned long ulSize, bool bUseMemPool)
{
    if(ulSize > m_ulUnitSize || false == bUseMemPool || 
        NULL == m_pMemBlock   || NULL == m_pFreeMemBlock)
    {
        return malloc(ulSize);
    }

    struct _Unit *pCurUnit = m_pFreeMemBlock;

    m_pFreeMemBlock = pCurUnit->pNext;            //從空閑鏈表中取出一個內存單元，放入已分配鏈表中，並返回該單元的內存地址
    if(NULL != m_pFreeMemBlock)
    {
        m_pFreeMemBlock->pPrev = NULL;
    }

    pCurUnit->pNext = m_pAllocatedMemBlock;
    
    if(NULL != m_pAllocatedMemBlock)
    {
        m_pAllocatedMemBlock->pPrev = pCurUnit; 
    }
    m_pAllocatedMemBlock = pCurUnit;

    return (void *)((char *)pCurUnit + sizeof(struct _Unit) );
}

void CMemPool::Free( void* p )
{
    if(m_pMemBlock<p && p<(void *)((char *)m_pMemBlock + m_ulBlockSize) )
    {
        struct _Unit *pCurUnit = (struct _Unit *)((char *)p - sizeof(struct _Unit) );

        m_pAllocatedMemBlock = pCurUnit->pNext;  //從已分配鏈表取出回收的內存單元，放入空閑鏈表中
        if(NULL != m_pAllocatedMemBlock)
        {
            m_pAllocatedMemBlock->pPrev = NULL;
        }

        pCurUnit->pNext = m_pFreeMemBlock;
        if(NULL != m_pFreeMemBlock)
        {
            m_pFreeMemBlock->pPrev = pCurUnit;
        }

        m_pFreeMemBlock = pCurUnit;
    }
    else
    {
        free(p);
    }