内存池的实现：数据结构部分是用的静态链表

                        类和模板实现

代码示例：

#include <iostream>
using namespace std;

const int MEM_POOL_SIZE = 10;

template<typename T>
class Queue
{
public:
	class QueueItem; //嵌套类的前置声明
	Queue();         //构造函数
	~Queue();        //析构函数
	void Push(T val);//入队
	void Pop();      //出队
	T Getfront();       //获取队头结点
	T Getback();        //获取队尾结点
	bool IsEmpty();  //判空
	void Show();     //打印
private:
	class QueueItem   //结点类
	{
	public:
		QueueItem(T val = T());         //结点构造
		~QueueItem();                   //结点析构
		void* operator new(size_t size);//重载new
		void operator delete(void* ptr);//重载delete
	public:
		T mdata;
		QueueItem* pnext;
		static QueueItem* pool;
	};
	QueueItem* pfront;
	QueueItem* prear;
};

//类外初始化静态成员变量
template<typename T>
typename Queue<T>::QueueItem* Queue<T>::QueueItem::pool = NULL;

//类外实现构造函数
template<typename T>
Queue<T>::Queue()
{
	pfront = prear = new QueueItem();
}

//类外实现析构函数
template<typename T>
Queue<T>::~Queue()
{
	QueueItem* pCur = pfront;
	QueueItem* pNext = pCur;
	while (pCur != NULL)
	{
		pNext = pCur->pnext;
		delete pCur;
		pCur = pNext;
	}
	pfront = prear = NULL;
}

//类外实现入队
template<typename T>
void Queue<T>::Push(T val)
{
	QueueItem* pNewNode = new QueueItem(val);
	prear->pnext = pNewNode;
	prear = prear->pnext;
}

//类外实现出队
template<typename T>
void Queue<T>::Pop()
{
	if (!IsEmpty())
	{
		QueueItem* pCur = pfront->pnext;
		pfront->pnext = pCur->pnext;
		delete pCur;
	}
	else
	{
		throw exception("Queue Empty");//如果为空就抛出异常
	}
}

//类外实现获取队头结点函数
template<typename T>
T Queue<T>::Getfront()
{
	if (!IsEmpty())
	{
		return pfront->pnext->mdata;
	}
	else
	{
		throw exception("Queue Empty");
	}
}

//类外实现获取队尾结点函数
template<typename T>
T Queue<T>::Getback()  
{
	if (!IsEmpty())
	{
		return prear->mdata;
	}
	else
	{
		throw exception("Queue Empty");
	}
}

//类外实现判空函数
template<typename T>
bool Queue<T>::IsEmpty()
{
	return pfront == prear;
}

//类外实现打印函数
template<typename T>
void Queue<T>::Show()
{
	QueueItem* pCur = pfront->pnext;
	while (pCur != NULL)
	{
		cout << pCur->mdata << " ";
		pCur = pCur->pnext;
	}
	cout << endl;
}

//类外实现嵌套类的构造函数
template<typename T>
Queue<T>::QueueItem::QueueItem(T val)
{
	mdata = val;
	pnext = NULL;
}

//类外实现嵌套类的析构函数 析构函数是空函数
template<typename T>
Queue<T>::QueueItem::~QueueItem(){}

//类外实现new的重载
template<typename T>
void* Queue<T>::QueueItem::operator new(size_t size)
{
	if (pool == NULL)
	{
		int allocsize = size*MEM_POOL_SIZE;
		pool = (QueueItem*)new char[allocsize];
		QueueItem* pCur = pool;
		for (pCur; pCur < pool + MEM_POOL_SIZE - 1; ++pCur)
		{
			pCur->pnext = pCur + 1;
		}
		pCur->pnext = NULL;
	}
	QueueItem* rt = pool;
	pool = pool->pnext;
	return rt;
}

//类外实现delete的重载
template<typename T>
void Queue<T>::QueueItem::operator delete(void* ptr)
{
	if (ptr == NULL)
		return;
	QueueItem* pCur = (QueueItem*)ptr;
	pCur->pnext = pool;
	pool = pCur;
}

int main()
{
	Queue<int> que;
	for (int i = 0; i < 15; ++i)
	{
		que.Push(i + 1);
	}
	que.Show();

	cout << que.Getfront() << endl;

	cout << que.Getback() << endl;

	cout << que.IsEmpty() << endl;

	que.Pop();//出队每次出第一个数据结点
	que.Show();

	return 0;
}

运行结果：