#include <iostream>
using namespace std;
class Demo
{
public:
	Demo(int a1 = 10, int a2 = 20)
		: _a1(a1)
		, _a2(a2)
	{
		cout << "Demo()" << endl;
	}
	void print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
	~Demo()
	{
		cout << "~Demo()" << endl;
	}
private:
	int _a1;
	int _a2;
};
void printIntArr(int* arr, int len)
{
	for (int i = 0; i < len; ++i)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
void printDemoArr(Demo* arr, int len)
{
	for (int i = 0; i < len; ++i)
	{
		arr[i].print();
	}
	cout << endl;
}
int main()
{
	//用 new 申請一個內置類型變量的空間
	int* pint1 = new int;
	cout << *pint1 << endl; //輸出 -842150451
	//使用括號中的值初始化變量
	int* pint2 = new int(5);
	cout << *pint2 << endl;	//輸出 5
	//用 delete 釋放一個變量的空間
	delete pint1;
	delete pint2;
	//用 new 申請一個自定義類型對象的空間，申請后會自動調用構造函數
	Demo* pd1 = new Demo;	//輸出 Demo()
	pd1->print();	//輸出 10 20
	//自定義類型會根據括號中的參數調用對應的構造函數
	Demo* pd2 = new Demo(5, 5);	//輸出 Demo()
	pd2->print();	//輸出 5 5
	//用 delete 釋放一個變量的空間，釋放前會自動調用析構函數
	delete pd1;	//輸出 ~Demo()
	delete pd2;	//輸出 ~Demo()
	//對內置類型用 new[] 開辟一塊連續的空間
	int* pint3 = new int[5];	//[]中表示開辟整形的個數
	printIntArr(pint3, 5);	//輸出 -842150451 -842150451 -842150451 -842150451 -842150451
	//用花括號中的值初始化開辟的連續空間，未給值的為 0
	int* pint4 = new int[5]{ 1, 2, 3, 4 };	
	printIntArr(pint4, 5);	//輸出 1 2 3 4 0
	//對內置類型用 delete[] 釋放一塊連續的空間
	delete[] pint3;
	delete[] pint4;
	//對自定義類型用 new[] 開辟一塊連續的空間
	//申請后會對空間自動調用構造函數 5 次
	Demo* pd3 = new Demo[5];	//輸出 5 行 Demo()
	printDemoArr(pd3, 5);	//輸出 5 行 10 20
	//用花括號中的值初始化開辟的連續空間
	//花括號中如果用小括號會被認為是逗號表達式，會去調用單參的構造函數
	//調用多參構造函數應在花括號中使用花括號，未給的值根據構造函數決定
	Demo* pd4 = new Demo[5]{ (1, 2), {5}, {5, 10}};	//輸出 5 行 Demo()
	printDemoArr(pd4, 5);	//輸出 第一行 2 20，第二行 5 10 第三行 5 10，兩行 10 20
	//對自定義類型用 delete[] 釋放一塊連續的空間
	//釋放之前會對空間自動調用析構函數 5 次
	delete[] pd3;	//輸出 5 行 ~Demo
	delete[] pd4;	//輸出 5 行 ~Demo
	return 0;
}

#include <iostream>
using namespace std;
int main()
{
	//operator new 和 malloc 使用方法一樣
	//operator new 申請空間失敗時拋異常
	int* pi = (int*)operator new(sizeof(int) * 4);
	//operator delete 和 free 使用方法一樣，都會調用 _free_dbg
	//operator delete 在釋放空間時會做一些檢查
	operator delete(pi);
	return 0;
}

#include <iostream>
using namespace std;
class Demo
{
public:
	Demo(int a1 = 10, int a2 = 20);
	~Demo();
private:
	int _a1;
	int _a2;
};
Demo::Demo(int a1, int a2)
	: _a1(a1)
	, _a2(a2)
{
	cout << "Demo()" << endl;
}
Demo::~Demo()
{
	cout << "~Demo()" << endl;
}
int main()
{
	Demo* pd1 = new Demo(5, 5);
	delete pd1;
	Demo* pd2 = new Demo[2]{ {1, 2}, {2, 3} };
	delete[] pd2;
	return 0;
}

#include <iostream>
using namespace std;
class Stack
{
public:
	Stack(int capacity = 4)
		: _a(new int[capacity])
		, _top(0)
		, _capacity(capacity)
	{
	}
	~Stack()
	{
		if (_a)
		{
			delete[] _a;
			_top = _capacity = 0;
		}
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack* ps = new Stack;
	//free(ps);	//內存泄漏
	//delete 釋放內存之前會調用析構函數
	delete ps;	//正確寫法
	return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << endl;
	}
	~A()
	{
		cout << "~A():" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = new A[10];
	//free(p1); 	//崩潰
	delete[] p1;	//正確寫法
	A* p2 = new A[10];
	//delete p2;	 //崩潰
	delete[] p2;	//正確寫法
	return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
//定位 new 又叫 replacement new
int main()
{
	//p1 現在指向的只是與 A 對象相同大小的一段空間，并不是一個對象，因為沒有調用構造函數
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;	//調用無參的構造函數 輸出 A()
	//可以手動調用析構函數，然后釋放空間
	p1->~A();	//輸出 ~A()
	free(p1);
	//p2 現在指向的只是與 A 對象相同大小的一段空間，并不是一個對象，因為沒有調用構造函數
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);	//10 是參數，可以根據參數調用對應的構造函數 輸出 A()
	p2->~A();	//輸出 ~A()
	operator delete(p2);
	return 0;
}