固定大小对象的内存池

#include <boost/progress.hpp>

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

    //从空闲列表中分配T元素
    inline void * alloc(size_t size);
    inline void free(void * someElement);
private:
    MemoryPool<T>* next;
    enum{EXPANSION_SIZE=2};
    //将空闲元素添加至空闲列表
    void expanTheFreeList(int howMany=EXPANSION_SIZE);
};

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

template<class T>
MemoryPool<T>::~MemoryPool()
{
    MemoryPool<T> * nextPrt=next;
    for(nextPrt=next;nextPrt!=NULL;nextPrt=next)
    {
        next=next->next;
        //        delete [] nextPrt;
        delete [](char*)nextPrt;
    }
}

template<class T>
inline void * MemoryPool<T>::alloc(size_t size)
{
    if(!next)
    {
        expanTheFreeList();
    }
    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);
    MemoryPool<T> *head=(MemoryPool<T>* )(doomed);
    head->next=next;
    next=head;
}

template<class T>
void MemoryPool<T>::expanTheFreeList(int howmany)
{
    size_t size=(sizeof(T)>sizeof(MemoryPool<T>*))? sizeof(T):sizeof(MemoryPool<T>*);
    //    MemoryPool<T>* runner =static_cast< MemoryPool<T>* >(new char [size]);
    MemoryPool<T>* runner =( MemoryPool<T>* )(new char [size]);
    next=runner;
    for(int i=0 ;i<howmany;i++)
    {
        //        runner->next=static_cast< MemoryPool<T>* >(new char [size]);
        runner->next=( MemoryPool<T>* )(new char [size]);
        runner=runner->next;
    }
    runner->next=0;
}

//使用内存池的类
class Rational
{
private:
    int n;
    int d;
    static MemoryPool<Rational > *memPool;
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(){    delete memPool; }
};

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

int main()
{
    //...
    Rational::newMemPool();
    //start time...

    //circle test like in the single thread memory pool.

    Rational::deleteMemPool();
    //stop time..
    return 0;
}