memory pool(内存池)的模板实现（暂不支持多线程）

#include <Windows.h>
#include <cassert>

template <typename T, int ALLOC_BLOCK_SIZE = 50>
class MemoryPool
{
public:
MemoryPool(void)
{
};
virtual ~MemoryPool(void)
{
};
static VOID* operator new(size_t allocLength)
{
assert(sizeof(T) >= sizeof(UCHAR*));
assert(sizeof(T) == allocLength);
/////没可用的block就重新分配
if(!freePtr)
{
allocBlock();
}
/////分配当前可用块freePtr给申请者，同时freePtr指向下一个可用的block
UCHAR* forreturn = freePtr;
freePtr = *reinterpret_cast<UCHAR**>(forreturn);
return forreturn;
};
static VOID operator delete(VOID* deletePtr)
{
/////deletePtr的下一个可用block指向freePtr，然后freePtr指向deletePtr
*reinterpret_cast<UCHAR**>(deletePtr) = freePtr;
freePtr = static_cast<UCHAR*>(deletePtr);
};
private:
/////alloc一定数量的内存block,然后将其串起来作为可用的block链
/////不过串的方式比较特殊，它是通过向每个block的前4(sizeof(UCHAR*))个
/////字节里写入下一个可用block块的起始地址来串起来的。
static void allocBlock()
{
freePtr = new UCHAR[sizeof(T) * ALLOC_BLOCK_SIZE];
UCHAR** forassign = reinterpret_cast<UCHAR**>(freePtr);
UCHAR* curPtr = freePtr;
for(int i = 0; i < ALLOC_BLOCK_SIZE - 1; i++)
{
curPtr += sizeof(T);
*forassign = curPtr;
forassign = reinterpret_cast<UCHAR**>(curPtr);
}
*forassign = 0;
};
private:
static UCHAR* freePtr;
};

template <typename T, int ALLOC_BLOCK_SIZE>
UCHAR* MemoryPool<T, ALLOC_BLOCK_SIZE>::freePtr = NULL;

#include <Windows.h>
#include <iostream>
#include "MemoryPool.h"
#include <time.h>

using namespace std;

class A : public MemoryPool<A>
{
private:
BYTE a[1024];
BYTE b[1025];
};

class B
{
private:
BYTE a[1024];
BYTE b[1024];
};

int _tmain(int argc, _TCHAR* argv[])
{
clock_t start, finish;
start = clock();
for(int i= 0; i < 2000000; i++)
{
A* pa = new A();
delete pa;
}
finish = clock();
cout<<"use memory pool : elapsed "<<(finish - start)<<"ms"<<endl;

start = clock();
for(int i= 0; i < 2000000; i++)
{
B* pb = new B();
delete pb;
}
finish = clock();
cout<<"not use : elapsed "<<(finish - start)<<"ms"<<endl;

system("pause");

return 0;
}