深入理解C++中的new和delete并实现对象池

new int(20);//初始化20  
new int[20]();//开辟数组是不支持初始化值的，但是支持写个空括号，表示给每个元素初始化为0 ，相当于每个元素调用int（）成为0

try//可能发生错误的代码放在try里面 
	{
		int *p = new int;
		delete []p;

		int *q = new int[10];
		delete q;
	}
	catch (const bad_alloc &err)//捕获相应类型的异常 
	{
		cerr << err.what() << endl;//打印错误 
	}

new -> 对operator new重载函数的调用 
delete -> 对operator delete重载函数的调用 

//先调用operator new开辟内存空间、然后调用对象的构造函数（初始化）
void* operator new(size_t size)
{
	void *p = malloc(size);
	if (p == nullptr)
		throw bad_alloc();
	cout << "operator new addr:" << p << endl;
	return p;
}
//delete p; 先调用p指向对象的析构函数、再调用operator delete释放内存空间
void operator delete(void *ptr)
{
	cout << "operator delete addr:" << ptr << endl;
	free(ptr);
}

void* operator new[](size_t size)
{
	void *p = malloc(size);
	if (p == nullptr)
		throw bad_alloc();
	cout << "operator new[] addr:" << p << endl;
	return p;
}
void operator delete[](void *ptr)
{
	cout << "operator delete[] addr:" << ptr << endl;
	free(ptr);
}

class Test
{
public:
	Test(int data = 10) { cout << "Test()" << endl; }
	~Test() { cout << "~Test()" << endl; }
private:
	int ma;
};

new delete
new[] delete[]

#include <iOStream>
using namespace std;

template<typename T>
class Queue
{
public:
	Queue()//构造函数 0构造（默认构造） 
	{
		_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);//malloc
		_rear->_next = item;
		_rear = item;
	}
	void pop()//出队操作 队头出 头删法 
	{
		if (empty())
			return;
		QueueItem *first = _front->_next;
		_front->_next = first->_next;
		if (_front->_next == nullptr)//队列原本只有1个有效元素节点 
		{
			_rear = _front;
		}
		delete first;//free
	}
	T front()const//获取首元素的值 
	{
		return _front->_next->_data;
	}
	bool empty()const { return _front == _rear; }//判空  链式队列 
private:
	//产生一个QueueItem的对象池（10000个QueueItem节点）
	struct QueueItem//节点类型，链式队列，带头节点的单链表 
	{
		QueueItem(T data = T()) :_data(data), _next(nullptr) {}//构造函数
		 
		//给QueueItem提供自定义内存管理
		void* operator new(size_t size)
		{
			if (_itemPool == nullptr)//如果对象池满了，对象池的指针就指向空了，然后现在进入，再开辟一个对象池 
			{
				_itemPool = (QueueItem*)new char[POOL_ITEM_SIZE*sizeof(QueueItem)];//开辟池 
				QueueItem *p = _itemPool;
				for (; p < _itemPool + POOL_ITEM_SIZE - 1; ++p)//连在一个链表上 
				{
					p->_next = p + 1;//因为节点内存是连续开辟的 可以用p+1 
				}
				p->_next = nullptr;
			}

			QueueItem *p = _itemPool;
			_itemPool = _itemPool->_next;
			return p;
		}
		void operator delete(void *ptr)
		{
			QueueItem *p = (QueueItem*)ptr;
			p->_next = _itemPool;
			_itemPool = p;//往头前放，然后连起来 
		}
		T _data;//数据域 
		QueueItem *_next;//指向下一个节点的指针域 
		static QueueItem *_itemPool;//指向对象池的起始地址，因为所有的 QueueItem都放在一个对象池里面 
		static const int POOL_ITEM_SIZE = 100000;//开辟的对象池的节点的个数，静态常量可以直接在类体初始化 
	};

	QueueItem *_front;//指向头节点
	QueueItem *_rear;//指向队尾 即链表的最后一个元素 
};

template<typename T>//在类外定义静态成员变量 
typename Queue<T>::QueueItem *Queue<T>::QueueItem::_itemPool = nullptr;
//typename告诉编译器后边的嵌套类作用域下的名字是类型，放心使用吧 

int main()
{
	Queue<int> que;
	for (int i = 0; i < 1000000; ++i)
	{
		que.push(i);//QueueItem(i)
		que.pop();//QueueItem
	}
	cout << que.empty() << endl;

	return 0;
}