C++对象池

#include<iostream>
#include<queue>
using namespace std; 

template<typename T>
class Queue
{
public:
	Queue()
	{
		_front = _rear = new QueueItem();
	}
	~Queue()
	{
		QueueItem* cur = _front;
		while (cur != nullptr)
		{
			_front = _front->_next;
			delete cur;
			cur = _front;
		 }
	}
	void push(const T& val)//入队
	{
		QueueItem* item = new QueueItem(val);
		_rear->_next = item;
		_rear = item;
	}
	void pop()
	{
		if (empty())
		{
			return;
		}
		QueueItem* first = _front->_next;

		_front->_next = first->_next;
		if (first->_next == nullptr)
		{
			_rear = _front;
		}
		delete first;
	}
	T front()const
	{
		return _front->next->_data;
	}
	bool empty()const
	{
		return _front == _rear;
	}
	void show()
	{
		QueueItem* it = _front->_next;
		while (it != nullptr)
		{
			cout << it->_data << " ";
			it = it->_next;
		}
		cout << endl;
	}
private:
	struct QueueItem
	{
		QueueItem(T data=T())
			:_data(data)
			,_next(nullptr)
		{ }

		//给QueueItem提供自定义的内存管理
		static void* operator new(size_t size)//开辟内存的时候对象还不存在
		{
			if (mypool == nullptr)
			{
				mypool = (QueueItem*)new char[POOL_ITEM_SIZE * sizeof(QueueItem)];
				QueueItem* p = mypool;
				for (; p < mypool + POOL_ITEM_SIZE - 1; ++p)
				{
					p->_next = p + 1;
				}
				p->_next = nullptr;
			}
			QueueItem* p = mypool;
			mypool = mypool->_next;
			return p;
		}
		static void operator delete(void* ptr)//释放内存的时候对象已经析构了
		{
			QueueItem* p = (QueueItem *) ptr;
			p->_next = mypool;
			mypool = p;
		}
		T _data;
		QueueItem* _next;
		static QueueItem* mypool;
		static const int POOL_ITEM_SIZE = 100000;
	};
	QueueItem* _front;//指向头节点
	QueueItem* _rear;//指向队尾
};
template<typename T>
typename Queue<T>::QueueItem* Queue<T>::QueueItem::mypool = nullptr;
int main()
{
	Queue<int>que;
	for (int i = 0; i < 100000; i++)
	{
		que.push(i);que.pop();//短时间大量的构造对象，释放内存效率极低
		//因此就考虑将大量对象存放在对象池中，使用对象时就不要在new,
		//直接从对象池拿，pop时也不要释放对象内存了，就直接归还到内存池就可以
	}
	que.show();
	cout << endl;  

	cout << que.empty() << endl;
	return 0;
}