#include <iostream>
using namespace std;
int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int) * 10);
	//new后面跟動態(tài)申請的類型
	int* p3 = new int;//動態(tài)申請一個int型空間
	int* pp3 = new int(1);//動態(tài)申請一個int型空間并初始化為1
	//動態(tài)申請10個int型空間并初始化
	int* p4 = new int[10]{ 1,2,3 };
	free(p1);
	free(p2);
	delete p3;
	delete pp3;
	delete[] p4;
}

#include <iostream>
using namespace std;
class Test
{
public:
	Test(int data = 10)
		: _data(data)
	{
		cout << "Test():" << endl;
	}
	~Test()
	{
		cout << "~Test():" << endl;
	}
private:
	int _data;
};
int main()
{	
	// 申請單個Test類型的空間
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	// 申請10個Test類型的空間
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);
	// 申請單個Test類型的對象
	Test* p3 = new Test;	//申請空間并調(diào)用構(gòu)造函數(shù)初始化
	delete p3;
	// 申請10個Test類型的對象
	Test* p4 = new Test[10];//申請空間并調(diào)用構(gòu)造函數(shù)初始化
	delete[] p4;
	return 0;
}

#include <iostream>
using namespace std;
class Stack
{
public:
	Stack(int capacity = 4)
		:_capacity(capacity)
	{
		int* _p = new int[capacity];
		_top = 0;
		_capacity = capacity;
		cout << "Stack()" << endl;
	}
	~Stack()
	{
		delete[] _p;
		_top = _capacity = 0;
		cout << "~Stack()" << endl;
	}
private:
	int* _p;
	int _top;
	int _capacity;
};
int main()
{	
	Stack* s1=new Stack;
	delete s1;
	return 0;
}

int main()
{	//由于申請空間過大new失敗
	char* p = new char[1024u * 1024u * 1024u * 2 - 1];  
	printf("execute\n");
	return 0;
}

#include <iostream>
using namespace std;
int main()
{	
	try    //檢測異常
	{
		char* p = new char[1024u * 1024u * 1024u * 2 - 1];  //new失敗，直接跳到catch，不執(zhí)行下面語句
		printf("execute\n");
	}
	catch (const exception& e)	//捕獲并處理異常
	{
		cout << e.what() << endl;
	}
	return 0;
}

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;
	ListNode(int val = 0)
		:_next(nullptr)
		,_prev(nullptr)
		,_data(val)
	{}
	void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);	//allocator是STL中的內(nèi)存池
		cout << "memory pool allocate" << endl;
		return p;
	}
	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}
};
class List
{
public:
	List()
	{
		_head = new ListNode;
		_head->_next = _head;
		_head->_prev = _head;
	}
	void ListPush(int val)
	{
		ListNode* newnode = new ListNode;
		newnode->_data = val;
		ListNode* tail = _head->_prev;
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;
	}
	~List()
	{
		ListNode* cur = _head->_next;
		while (cur != _head)
		{
			ListNode* next = cur->_next;
			delete cur;
			cur = next;
		}
		delete _head;
		_head = nullptr;
	}
private:
	ListNode* _head;
};
int main()
{
	List l;
	l.ListPush(1);
	l.ListPush(2);
	l.ListPush(3);
	l.ListPush(4);
	return 0;
}

#include <iostream>

using namespace std;

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

private:
	int _data;
};
//構(gòu)造函數(shù)是不支持直接手動調(diào)用的，所以引入定位new，對已經(jīng)存在的對象調(diào)用構(gòu)造函數(shù)初始化，常用于內(nèi)存池中的對象
int main()
{	
//調(diào)用operator new申請空間，operator new和malloc函數(shù)用法類似
	Test* p = (Test*)operator new(sizeof(Test));
	//調(diào)用構(gòu)造函數(shù)初始化
	new(p)Test(1);	//定位new，new后面接要初始化對象的地址+類型，(1)表示初始化為1
	//先調(diào)用析構(gòu)函數(shù)，析構(gòu)函數(shù)可以直接調(diào)用
	p->~Test();
	//在調(diào)用operator delete釋放空間
	operator delete (p);
	

	return 0;
}