适用于类和结构体的内存池模板类

   原理很简单，就是先开辟n个数据块，每个数据块的前四个字节next_id表示下一个可用的数据块的编号。该内存池类中有一个成员m_firstId, 表示第一个可用的数据块的编号，然后在申请内存的时候，根据这个编号，返回对应的数据块的地址。在将申请的内存块A归还给内存池时,根据其地址确定其所在的内存块编号。然后将该内存块的next_id改为m_firstId,将m_firstId改为该内存块的id。

 

Mempool.h

#ifndef _MEM_POOL_H_
#define _MEM_POOL_H_

#include "Lock.hpp"

template<class T>
class Mempool
{
public:
    struct BlockNode
    {
        int        next_id;
        T          data;
    };

public:
    Mempool(int nCount)
        :m_nCount(nCount)
        ,m_firstId(-1)
        ,m_NodeHead(NULL)
        ,m_pNode(NULL)
    {
        m_NodeHead = (BlockNode*)malloc(sizeof(BlockNode) * m_nCount);
        if(m_NodeHead == NULL)
        {
            return;
        }

        memset(m_NodeHead, 0, sizeof(BlockNode) * m_nCount);

        m_pNode = new BlockNode*[m_nCount];

        memset(m_pNode, 0, sizeof(BlockNode*) * m_nCount);

        BlockNode* temp = m_NodeHead;

        for(int i = 0; i < m_nCount; ++i)
        {
            m_pNode[i] = temp;
            temp->next_id = i + 1;
            temp = (BlockNode*)((char*)temp + sizeof(BlockNode));

            if(i == m_nCount - 1)
            {
                temp->next_id = -1;
            }
        }

        m_firstId = 0;
    }

    ~Mempool()
    {
        if(m_NodeHead)
        {
            free(m_NodeHead);
            m_NodeHead = NULL;
        }

        if(m_pNode)
        {
            delete []m_pNode;
            m_pNode = NULL;
        }
    }

    inline void* mallocMemBuf()
    {
        AutoLock lock(&m_lock);

        void* p = NULL;
        if(m_firstId != -1 && m_firstId < m_nCount)
        {
            p = (void*)&(m_pNode[m_firstId]->data);
            m_firstId = m_pNode[m_firstId]->next_id;
        }
        else
        {
            p = malloc(sizeof(T));
        }

        return p;
    }

    inline void freeMemBuf(void* pNode)
    {
        AutoLock lock(&m_lock);

        if((pNode >= (char*)m_NodeHead) && (pNode <= (char*)m_NodeHead + sizeof(BlockNode)* m_nCount))
        {
            for(int i = 0; i < m_nCount; ++i)
            {
                if(pNode == (void*)&(m_pNode[i]->data))
                {
                    m_pNode[i]->next_id = m_firstId;
                    m_firstId = i;
                    return;
                }
            }
        }

        free(pNode);
    }

private:
    int                m_nCount;            //the block count
    int                m_firstId;            //the first free block id
    BlockNode*         m_NodeHead;            //the head of the list
    BlockNode**        m_pNode;            //the pointer array
    Lock               m_lock;
};

#endif

运用实例

#include <iostream>
#include <time.h>
#include "Mempool.hpp"

using namespace std;

#define _MEM_POOL_

class Test
{
public:
    Test()
        :a(0)
        ,b(0)
    {
        count1++;
        //cout << "Test constructor!" << endl;
    }

    ~Test()
    {
        count2++;
        //cout << "Test destructor!" << endl;
    }

    void setA(int _a)
    {
        a = _a;
    }

    void setB(int _b)
    {
        b = _b;
    }

    void show()
    {
        cout << "a = " << a << " b = " << b << endl;
    }

#ifdef _MEM_POOL_

    inline void* operator new(unsigned int nSize )
    {
        if( mempool == NULL )
        {
            return malloc( nSize );
        }
        return mempool->mallocMemBuf( );
    };
    inline void operator delete(void* p)
    {
        if( mempool == NULL )
        {
            free( p );
        }
        else
        {
            mempool->freeMemBuf( p );
        }
    };

    static Mempool<Test> *mempool;

#endif

    static int count1;
    static int count2;


private:
    int a;
    int b;
    char data[2048];
};

int Test::count1 = 0;
int Test::count2 = 0;
#ifdef _MEM_POOL_
Mempool<Test>* Test::mempool = NULL;
#endif

int main()
{
#ifdef _MEM_POOL_
    Test::mempool = new Mempool<Test>(5);
#endif

    clock_t start, end;
    double duration;

    start = clock();

    for(int i = 0 ; i < 10000000; ++i)
    {
        Test *t = new Test;
        //t->show();
        delete t;
    }

    //cout << "count1 = " << Test::count1 << " count2 = " << Test::count2 << endl;

    end = clock();

    duration = double(end - start) / CLOCKS_PER_SEC;

    cout << "total used " << duration << "s" << endl;

    system("pause");

    return 0;

}