C++实现内存池

想用C++实现内存池，参考了一下别人的代码
http://blog.csdn.net/chexlong/article/details/7071922
人家对内存块的管理是用vector,动态的插入与删除，来做内存的分配与回收，基于人家的代码，做的一些改动，用Map进行管理，用标志来区分该内存块是否已分配，回收时，内存里面的内容也得重置掉，以免影响下一次的调用。
代码如下

#ifndef _MEM_POOL_H
#define _MEM_POOL_H

#include <vector>
#include <iostream>
#include <map>
#include "string.h"


using namespace std;

/*
在内存池中分配固定大小的内存块

该类的目的是加速内存分配速度，并且减少因重复分配相同
内存时产生的内存碎片，比如在服务器应用程序中。
*/

struct sBlock
{
    short   isHasUse; // 是否使用过
    int     iIndx;    // 编号
    char*   pBlock;   // 内存块所指向的地址
};

class CMemPool
{
public:

    //创建大小为blockSize的内存块，内存池数目为预分配的数目preAlloc
    CMemPool(std::size_t blockSize, int preAlloc = 0);

    ~CMemPool();

    //获取一个内存块。如果内存池中没有足够的内存块，则会自动分配新的内存块
    //如果分配的内存块数目达到了最大值，则会返回一个异常
    void* Get();

    //释放当前内存块，将其插入内存池
    void Release(void* ptr);

    //返回内存块大小
    std::size_t BlockSize() const;

    //返回内存池中内存块数目
    int Allocated() const;

    //返回内存池中可用的内存块数目
    int Available() const;

    //得到内存块的数量
    int GetBlockNum() const;

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

    enum
    {
        BLOCK_RESERVE = 32
    };

    typedef std::vector<char*> BlockVec;

    std::size_t m_blockSize;
    int         m_maxAlloc;
    int         m_allocated;
    BlockVec    m_blocks;

    typedef map<int, sBlock> BlockMap;
    BlockMap    m_blocks_map;

};

inline std::size_t CMemPool::BlockSize() const
{
    return m_blockSize;
}


// 得到已经分配出去的有多少
inline int CMemPool::Allocated() const
{
    int iTotalUseNum = 0;
    for (auto it = m_blocks_map.begin(); it != m_blocks_map.end(); ++it)
    {
        if (it->second.isHasUse == 1)
        {
            iTotalUseNum += 1;
        }
    }
    return iTotalUseNum;
}

inline int CMemPool::Available() const
{
    int iAvailableNum = 0;
    for (auto it = m_blocks_map.begin(); it != m_blocks_map.end(); ++it)
    {
        if (it->second.isHasUse == 0)
        {
            iAvailableNum += 1;
        }
    }
    return iAvailableNum;
}

inline int CMemPool::GetBlockNum() const
{
    return m_blocks_map.size();
}

CMemPool::CMemPool(std::size_t blockSize, int preAlloc) :
m_blockSize(blockSize),
m_allocated(preAlloc)
{
    m_blocks_map.clear();
    for (int i = 0; i < preAlloc; ++i)
    {
        sBlock nBlock;
        nBlock.isHasUse = 0;
        nBlock.iIndx = i;
        nBlock.pBlock = new char[m_blockSize];
        m_blocks_map[i] = nBlock;
    }

}

CMemPool::~CMemPool()
{
    for (BlockMap::iterator it = m_blocks_map.begin(); it != m_blocks_map.end(); ++it)
    {

        cout << " delete the block indx = " << it->second.iIndx << "  " << endl;
        delete[] it->second.pBlock; // 删除内存对应的内存空间
    }
    m_blocks_map.clear();
}


void* CMemPool::Get()
{
     // 分配内存地址
    for (auto it = m_blocks_map.begin(); it != m_blocks_map.end(); ++it)
    {
        if (it->second.isHasUse == 0)
        {
            it->second.isHasUse = 1; // 表示该内存块已经被分配出去了
            cout << " this block indx = " << it->second.iIndx << "  has be used " << endl;
            return it->second.pBlock;
        }
    }

    // 如果内存map 都被用完啦,那么则得添加新的内存块到map中
    auto iter = m_blocks_map.end();
    iter--; // 得往后减一个，才能取到最后一个元素

    int maxIndx = iter->second.iIndx;

    int curIndx = maxIndx + 1;
    sBlock nBlock;
    nBlock.iIndx = curIndx;
    nBlock.isHasUse = 0;
    nBlock.pBlock = new char[m_blockSize];
    m_blocks_map[curIndx] = nBlock;

    // 将新添加的分配出来用
    m_blocks_map[curIndx].isHasUse = 1;
    cout << " this block indx = " << m_blocks_map[curIndx].iIndx << " create and  has be used " << endl;
    return m_blocks_map[curIndx].pBlock;

}


void CMemPool::Release(void* ptr)
{
    for (auto it = m_blocks_map.begin(); it != m_blocks_map.end(); ++it)
    {
        char * pTmp = reinterpret_cast<char*>(ptr);
        if (it->second.pBlock == pTmp)
        {
            cout << " the block indx = " << it->second.iIndx << "   has be Released " << endl;
            it->second.isHasUse = 0;
            memset(pTmp, 0, m_blockSize);
        }
    }
}


#endif

测试代码

#include "MemPool.h"

#define DATA_BLOCK_LEN 50

struct  sTest
{
    int m_id;
    int m_num;
};

struct  sTest2
{
    int m_id;
    int m_num;
    char m_str[10];
};

int main()
{
    CMemPool myPool1(DATA_BLOCK_LEN, 20);

    cout << "myPool1 block size = " << myPool1.BlockSize() << endl;
    cout << "myPool1 allocated block num = " << myPool1.Allocated() << endl;
    cout << "myPool1 available block num = " << myPool1.Available() << endl;
    cout << "myPool1 total block num = " << myPool1.GetBlockNum() << endl <<endl;

    // 分配一个内存块
    struct sTest* pTest;
    pTest = (struct sTest*)(myPool1.Get());

    pTest->m_id = 25;
    pTest->m_num = 10000;
    cout << pTest->m_id <<"  " <<pTest->m_num << endl;

    struct sTest* pTest2;
    pTest2 = (struct sTest*)(myPool1.Get());

    pTest2->m_id = 123;
    pTest2->m_num = 13445;
    cout << pTest2->m_id << "  " << pTest2->m_num << endl << endl;


    cout << "myPool1 allocated block num = " << myPool1.Allocated() << endl;
    cout << "myPool1 available block num = " << myPool1.Available() << endl << endl;

    // 回收该内存块
    myPool1.Release(pTest);
    pTest = NULL;

    cout << "myPool1 allocated block num = " << myPool1.Allocated() << endl;
    cout << "myPool1 available block num = " << myPool1.Available() << endl << endl;

    //pTest = (struct sTest*)(myPool1.Get());
    //cout << pTest->m_id << endl;
    //cout << pTest->m_num << endl;
    struct sTest2* pTtmp;
    pTtmp = (struct sTest2*)(myPool1.Get());
    pTtmp->m_id = 1234;
    char * cTmp= "skskdlsl";
    memcpy(pTtmp->m_str, cTmp, strlen(cTmp));
    cout << pTtmp->m_str << endl;

    cout << "myPool1 allocated block num = " << myPool1.Allocated() << endl;
    cout << "myPool1 available block num = " << myPool1.Available() << endl << endl;

    myPool1.Release(pTtmp);

    for (int i = 0; i < 30; ++i)
    {
        struct sTest* pTest3;
        pTest3 = (struct sTest*)(myPool1.Get());

        pTest3->m_id = 123;
        pTest3->m_num = 13445;
        cout << pTest3->m_id << "  " << pTest3->m_num << endl << endl;
        cout << "myPool1 allocated block num = " << myPool1.Allocated() << endl;
        cout << "myPool1 available block num = " << myPool1.Available() << endl;
        cout << "myPool1 total block num = " << myPool1.GetBlockNum() << endl << endl;
    }

    int iWait;
    cin >> iWait;

    return 0;
}