一个内存分配器 模板基类

#include <iostream>

#include <algorithm>

template<typename T> class Cached

{

public :

void * operator new(size_t size);

void operator delete(void *, size_t size);

~Cached(){}

protected:

T * next;

private:

static T * freeStore;

static size_t count;

static void addToFreeList(T*);

static std::allocator<T> alloc;

};

template<typename T> T * Cached<T>::freeStore=0;

template<typename T> size_t Cached<T>::count =2;

template<typename T> std::allocator<T> Cached<T>::alloc;

template<typename T> void Cached<T>::addToFreeList(T* ptr)

{

ptr->next=freeStore;

freeStore=ptr;

}

template<typename T> void * Cached<T>::operator new(size_t size)

{

if(size!=sizeof(T))

throw std::runtime_error("error occur in function operator new ,because of wrong size");

if(!freeStore)

{

T * ptr=alloc.allocate(count);

for(int i=0;i!=count;++i)

{

(ptr+i)->next=freeStore;

freeStore=(ptr+i);

}

}

T * ret=freeStore;

freeStore=freeStore->next;

return ret;

}

template< typename T> void Cached<T>::operator delete(void * ptr,size_t size)

{

Cached<T>::addToFreeList(static_cast<T*>(ptr));

}

class A:public Cached<A>

{

public:

A():a(9),b(3){}

int a,b;

void show(){std::cout<<a<<b<<std::endl;}

};

int main(int argc,char * argv[])

{

A *obj=new A();

A *obj1=new A();

A *obj2=new A();

delete obj2;

obj1->show();

::system("pause");

return 0;

}