内存池（创建以后基本不释放，要释放需要自己实现这个功能）

//单例模式的

#include<iostream>
#include<string>

const int MEM_SIZE = 10;
template<typename T>
class MEM_Management  //单例模式
{
public:
	static MEM_Management<T>* getInstance()
	{
		return &mm;
	}
	void* alloc(size_t size)
	{
		if (pool == NULL)
		{
			pool = (Node*)new char[(size + 4) * MEM_SIZE];
			Node* pCur = pool;
			for (pCur; pCur < pool + MEM_SIZE - 1; pCur = pCur + 1)
			{
				pCur->pnext = pCur + 1;
			}
			pCur->pnext = NULL;
		}
		void* ptr = pool;
		pool = pool->pnext;
		return ptr;
	}
	void dealloc(void* ptr)
	{
		if (ptr == NULL)
			return;
		Node* mptr = (Node*)ptr;
		mptr->pnext = pool;
		pool = mptr;
	}
private:
	MEM_Management() :pool(NULL){}
	MEM_Management(const MEM_Management<T>&);
	class Node
	{
	public:
		Node(T val = T()) :mdata(val), pnext(NULL){}
	public:
		T mdata;
		Node* pnext;
	};
	Node* pool;
	static MEM_Management<T> mm;//MEM_Management<T> 类生成了一个对象 mm
};
template<typename T>
MEM_Management<T> MEM_Management<T>::mm; //static成员在类外初始化



class Student
{
public:
	Student(std::string name, int age, bool sex) :
		mname(name), mage(age), msex(sex){}
	void* operator new(size_t size)
	{
		return pmm->alloc(size);
	}
	void operator delete(void* ptr)
	{
		pmm->dealloc(ptr);
	}
private:
	std::string mname;
	int mage;
	bool msex;
	static MEM_Management<Student>* pmm;
};
MEM_Management<Student>* Student::pmm = MEM_Management<Student>::getInstance();


int main()
{
	Student* pstu1 = new Student("zhangsan", 20, false);
	Student* pstu2 = new Student("lisi", 22, false);
	Student* pstu3 = new Student("wangwu", 21, true);

	delete pstu2;
	return 0;
}

 

普通版本：

#include<iostream>
#include<string>

template<typename T>
class Queue;

template<typename T> //
class QueueItem
{
public:
	QueueItem(T val = T()) :mdata(val), pnext(NULL){}
	void* operator new(size_t size)  //自己实现的new，用于实现池的资源的分配
	{
		if (pool == NULL)
		{
			pool = (QueueItem<T>*)new char[sizeof(QueueItem<T>) * 10];
			QueueItem<T>* pCur = pool;
			for (pCur; pCur < pool + 9; pCur = pCur + 1) //类似于静态链表初始化
			{
				pCur->pnext = pCur + 1;
			}
			pCur->pnext = NULL;
		}
		void* ptr = pool;
		pool = pool->pnext;
		return ptr;
	}
	void operator delete(void* ptr) //自己实现的delete，用于回收池资源
	{
		if (ptr == NULL)
			return;
		QueueItem<T>* mptr = (QueueItem<T>*)ptr;
		mptr->pnext = pool;
		pool = mptr;
	}
private:
	T mdata;  //队结点的数据域
	QueueItem<T>* pnext; //next域。将其指针域和数据域看作是静态链表来处理，只保存空闲结点，申请出去的结点由用户处理
	static QueueItem<T>* pool;
	friend class Queue<T>;
};

template<typename T>
QueueItem<T>* QueueItem<T>::pool = NULL;


template<typename T>
class Queue
{
public:
	Queue()
	{
		phead = ptail = new QueueItem<T>();//10个大小
	}
	~Queue()
	{
		QueueItem<T>* pCur = phead;
		QueueItem<T>* pBack = pCur;
		while (pCur != NULL)
		{
			pBack = pCur->pnext;
			delete pCur;
			pCur = pBack;
		}
		phead = ptail = NULL;
	}
	void Inque(T val)
	{
		QueueItem<T>* pnewitem = new QueueItem<T>(val); //把new出来的 void* 强转为 QueueItem<T>*

		ptail->pnext = pnewitem;
		ptail = pnewitem;
	}
	void Outque()
	{
		if (empty())
		{
			throw std::exception("queue is empty!");
		}
		QueueItem<T>* pCur = phead->pnext;
		phead->pnext = pCur->pnext;
		delete pCur;
	}
	T front()
	{
		if (empty())
		{
			throw std::exception("queue is empty!");
		}
		return phead->pnext->mdata;
	}
	bool empty()
	{
		return (phead == ptail) && (phead != NULL);
	}
private:
	QueueItem<T>* phead;
	QueueItem<T>* ptail;
};


int main()
{
	Queue<int> que;
	for (int i = 0; i < 100; i++)
	{
		que.Inque(i + 1);
	}
	int rt = 0;
	for (int i = 0; i < 100; i++)
	{
		rt = que.front();
		std::cout << rt << " ";
		que.Outque();
	}
	std::cout << std::endl;
	return 0;
}