用模版实现简单的内存池

程序中有时候会遇到这种情况，就是需要不停的去分配以及释放内存。带来的是不停的调用new以及delete带来的开销。

而且由于全局的new以及delete往往对多线程做出了并发保护，所以在单线程情况下这更带来一种浪费，一般的情况下是去实现一个

单线程的内存池来进行性能优化，配合所需的类往往带来很好的性能提升。

首先是作为内存池的模板类：

template<class T>
class MemoryPool{
public:
    MemoryPool(size_t size = EXPANSION_SIZE);
    ~MemoryPool();

    //从空闲列表中分配T大小的空间
    inline void * alloc(size_t size);

    //释放内存到空闲列表中
    inline void free(void * elements);
private:
    MemoryPool<T> * next;   //空闲列表的下一个元素
    enum { EXPANSION_SIZE = 32 };
    void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template<class T>
MemoryPool<T>::MemoryPool(size_t size)
{
    expandTheFreeList(size);
}

template<class T>
MemoryPool<T>::~MemoryPool()
{
    MemoryPool<T> * nextPtr = next;
    if (next){
        for (nextPtr = next; nextPtr != nullptr; nextPtr = next){
            next = next->next;
            delete[] ((char * )nextPtr);    //这里的强制类型转换应该注意，不转换编译无法通过的当时分配
                                            //内存的时候是按照char类型分配的，那么释放的时候也应该同样释放。
        }
    }
}


template<class T>
inline
void * MemoryPool<T>::alloc(size_t)
{
    if (!next)
        expandTheFreeList();
    MemoryPool<T> * head = next;
    next = head->next;//分配了一块空间
    return head;
}

template<class T>
inline
void MemoryPool<T>::free(void * doomed)
{
    MemoryPool<T> * head = static_cast<MemoryPool<T> *>(doomed);
    head->next = next;
    next = head;
}

template<class T>
void MemoryPool<T>::expandTheFreeList(int howMany)
{
    //保证分配的内存大小至少应该是大于指针大小或者是元素大小中的 最大者，因为二者之间是共享内存的
    size_t sizeAlloc = (sizeof(T) > sizeof(MemoryPool<T> *)) ?
        sizeof(T) : sizeof(MemoryPool<T> *);
    MemoryPool<T> * runner = (MemoryPool<T>*)(new char[sizeAlloc]); //这里实际上是可以使用static_cast的，但是不知道为什么，
    next = runner;                                              //gcc下编译不能通过。可能因为gcc的限制比较严格。无奈，只能使用普通的强制类型转换
    for (int i = 0; i < howMany; ++i){
        runner->next = (MemoryPool<T>*)(new char[sizeAlloc]);
        runner = runner->next;
    }
    runner->next = 0;
}

下面是使用该内存池的一个rational类，代码如下：

class Rational{
public:
    Rational(int a = 0, int b = 1):n(a), d(b){}
    void * operator new(size_t size){return memPool->alloc(size); }
    void operator delete(void * doomed, size_t size){memPool->free(doomed);}
    static void newMemPool(){memPool = new MemoryPool<Rational>; }
    static void deleteMemPool()
    {
        if(!memPool)
            return;
        delete memPool;
    }
private:
    int n;
    int d;
    static MemoryPool <Rational> * memPool;
};

使用代码如下：

MemoryPool<Rational> * Rational::memPool = 0;

int main()
{
    Rational * array[10];
    Rational::newMemPool();
    for(int j = 0; j < 2; ++j){
        for(int i = 0; i < 10; i++){
            array[i] = new Rational(i);
        }
        for(int i = 0; i < 10; i++){
            delete array[i];
        }
    }
    Rational::deleteMemPool();
}