new int(20);//初始化20  
new int[20]();//開辟數(shù)組是不支持初始化值的，但是支持寫個空括號，表示給每個元素初始化為0 ，相當于每個元素調用int（）成為0

try//可能發(fā)生錯誤的代碼放在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重載函數(shù)的調用 
delete -> 對operator delete重載函數(shù)的調用 

//先調用operator new開辟內存空間、然后調用對象的構造函數(shù)（初始化）
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指向對象的析構函數(shù)、再調用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()//構造函數(shù) 0構造（默認構造） 
	{
		_front = _rear = new QueueItem();
	}
	~Queue()//析構函數(shù) 
	{
		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個有效元素節(jié)點 
		{
			_rear = _front;
		}
		delete first;//free
	}
	T front()const//獲取首元素的值 
	{
		return _front->_next->_data;
	}
	bool empty()const { return _front == _rear; }//判空  鏈式隊列 
private:
	//產(chǎn)生一個QueueItem的對象池（10000個QueueItem節(jié)點）
	struct QueueItem//節(jié)點類型，鏈式隊列，帶頭節(jié)點的單鏈表 
	{
		QueueItem(T data = T()) :_data(data), _next(nullptr) {}//構造函數(shù)
		 
		//給QueueItem提供自定義內存管理
		void* operator new(size_t size)
		{
			if (_itemPool == nullptr)//如果對象池滿了，對象池的指針就指向空了，然后現(xiàn)在進入，再開辟一個對象池 
			{
				_itemPool = (QueueItem*)new char[POOL_ITEM_SIZE*sizeof(QueueItem)];//開辟池 
				QueueItem *p = _itemPool;
				for (; p < _itemPool + POOL_ITEM_SIZE - 1; ++p)//連在一個鏈表上 
				{
					p->_next = p + 1;//因為節(jié)點內存是連續(xù)開辟的 可以用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;//數(shù)據(jù)域 
		QueueItem *_next;//指向下一個節(jié)點的指針域 
		static QueueItem *_itemPool;//指向對象池的起始地址，因為所有的 QueueItem都放在一個對象池里面 
		static const int POOL_ITEM_SIZE = 100000;//開辟的對象池的節(jié)點的個數(shù)，靜態(tài)常量可以直接在類體初始化 
	};

	QueueItem *_front;//指向頭節(jié)點
	QueueItem *_rear;//指向隊尾 即鏈表的最后一個元素 
};

template<typename T>//在類外定義靜態(tài)成員變量 
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;
}