内存池

内存池：为了解决new、malloc申请内存块的大小不定，频繁使用会产生大量的内存碎片、效率低等问题。

基本思想：在真正使用内存前，先申请分配一定数量的、大小相等的内存块备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。

内存分配alloc（）：申请一定数量的、大小相等的内存块，当使用内存时，从内存池中分出一部分内存块

void* alloc(size_t size)
	{
		if(pool == NULL)
		{
			pool = (Node *)new char[(size + 4) * MEM_SIZE];//会产生4个字节浪费
			Node* pCur = pool;
			for(pCur; i < pool + MEM_SIZE - 1; ++pCur)
			{
				pCur->pnext = pCur + 1;
			}
			pCur-pnext = NULL;
		}
		Node* rt = pool;
		pool = rt->pnext;
		return rt;
	}

内存释放dealloc（）：将内存回收入内存块

void dealloc(void * ptr)
	{
		if(ptr == NULL)
			return;
		Node* mptr = (Node*)ptr;
		mptr->pnext = pool;
		pool = mptr;
	}

 对于一个类只会生成一个内存池对象（单例模式）

const int MEM_SIZE = 10;

template<typename T>
class MEM_POOL
{
public:
	static MEM_POOL<T>&  getInstance()
	{
		return mempool;
	}

	void* alloc(size_t size)
	{
		if(pool == NULL)
		{
			pool = (Node *)new char[(size + 4) * MEM_SIZE];//会产生4个字节浪费
			Node* pCur = pool;
			for(pCur; pCur < pool + MEM_SIZE - 1; ++pCur)
			{
				pCur->pnext = pCur + 1;
			}
			pCur->pnext = NULL;
		}
		Node* rt = pool;
		pool = rt->pnext;
		return rt;
	}

	void dealloc(void * ptr)
	{
		if(ptr == NULL)
			return;
		Node* mptr = (Node*)ptr;
		mptr->pnext = pool;
		pool = mptr;
	}

private:
	MEM_POOL(){}
	MEM_POOL(const MEM_POOL<T>& ) {}

	class Node
	{
	public:
		Node(T val = T()): mdata(val), pnext(NULL)
		{}
	public:
		T mdata;
		Node * pnext;
	};
	static Node* pool;
	static MEM_POOL<T> mempool;
};
template <typename T>
typename MEM_POOL<T>::Node* MEM_POOL<T>::pool = NULL;
template<typename T>
MEM_POOL<T> MEM_POOL<T>::mempool ;