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

try//可能發(fā)生錯誤的代碼放在try里面 
	{
		int *p = new int;
		delete []p;

		int *q = new int[10];
		delete q;
	}
	catch (const bad_alloc &err)//捕獲相應(yīng)類型的異常 
	{
		cerr << err.what() << endl;//打印錯誤 
	}

new -> 對operator new重載函數(shù)的調(diào)用 
delete -> 對operator delete重載函數(shù)的調(diào)用 

//先調(diào)用operator new開辟內(nèi)存空間、然后調(diào)用對象的構(gòu)造函數(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; 先調(diào)用p指向?qū)ο蟮奈鰳?gòu)函數(shù)、再調(diào)用operator delete釋放內(nèi)存空間
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()//構(gòu)造函數(shù) 0構(gòu)造（默認(rèn)構(gòu)造） 
	{
		_front = _rear = new QueueItem();
	}
	~Queue()//析構(gòu)函數(shù) 
	{
		QueueItem *cur = _front;//指向頭結(jié)點 
		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; }//判空  鏈?zhǔn)疥犃?
private:
	//產(chǎn)生一個QueueItem的對象池（10000個QueueItem節(jié)點）
	struct QueueItem//節(jié)點類型，鏈?zhǔn)疥犃?，帶頭節(jié)點的單鏈表 
	{
		QueueItem(T data = T()) :_data(data), _next(nullptr) {}//構(gòu)造函數(shù)
		 
		//給QueueItem提供自定義內(nèi)存管理
		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é)點內(nèi)存是連續(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;//指向?qū)ο蟪氐钠鹗嫉刂?，因為所有?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;
}