#include<iostream>
using namespace std;
int main()
{
	int a = 3;
	int b = 4;
	int c = 5;
	int d = 6;
	cout <<"a:"<< &a << endl;
	cout << "b:"<<&b << endl;
	cout << "c:"<<&c << endl;
	cout << "d:"<<&d << endl;
	return 0;
}

#include<iostream>
using namespace std;
int main()
{
	int num = 10;
	while (num--)
	{
		int *p1 = (int*)malloc(sizeof(int));
		int *p2 = (int*)malloc(sizeof(int));
		cout <<"p1"<< p1 << endl;
		cout <<"p2"<<p2 << endl;
		cout << endl;
		free(p1);
	}
	return 0;
}

//C++開(kāi)辟動(dòng)態(tài)內(nèi)存的新玩法
//語(yǔ)法演示：
#include<iostream>
using namespace std;
int main()
{
	//申請(qǐng)一個(gè)int的動(dòng)態(tài)空間
	int* p1 = (int*)malloc(sizeof(int));
	*p1 = 1;
	int* p2 = new int(2);//這里是初始化
	free(p1);
	delete p2;
	//申請(qǐng)一個(gè)10各int的動(dòng)態(tài)數(shù)組
	int *p3 = (int*)malloc(sizeof(int)* 10);
	for (int i = 0; i < 10; i++)
	{
		p3[i] = i + 1;
	}
	int *p4 = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//初始化
	free(p3);
	delete[]p4;
	return 0;
}

#include<iostream>
using namespace std;
struct ListNode
{
	int _val;
	ListNode* _next;
	ListNode* _prev;
	//構(gòu)造函數(shù)
	ListNode(int val = 0)
	:_val(val)
	, _next(nullptr)
	, _prev(nullptr)
	{
        cout<<"ListNode(int val = 0)"<<endl;
    }
	~ListNode()
	{
		cout << "ListNode()" << endl;
	}
};
int main()
{
	//申請(qǐng)一個(gè)結(jié)點(diǎn)的空間
    ListNode* pa = (ListNode*)malloc(sizeof(ListNode)*4);
	ListNode* pb = new ListNode(1);//不用去用sizeof去計(jì)算空間大小，很方便   
	free(pa);
	delete pb;
	//申請(qǐng)4個(gè)結(jié)點(diǎn)的空間--當(dāng)然了一般不會(huì)這么玩兒，我們只是看看效果
	ListNode* pc = (ListNode*)malloc(sizeof(ListNode)* 4);
	ListNode* pd = new ListNode[4]{1, 2, 3, 4};
	free(pc);
	delete[]pd;
	return 0;
}

struct ListNode
{
	int _val;
	ListNode* _next;
	ListNode* _prev;
	//構(gòu)造函數(shù)
	ListNode(int val = 0)
		:_val(val)
		, _next(nullptr)
		, _prev(nullptr)
	{
		cout << "ListNode(int val = 0)" << endl;
	}
	~ListNode()
	{
		cout << "ListNode()" << endl;
	}
};
void f()
{
	// 他的用法跟malloc和free是完全一樣的，功能都是在堆上申請(qǐng)釋放空間
	// 失敗了處理方式不一樣，malloc失敗返回NULL，operator new失敗以后拋異常
	ListNode* p1 = (ListNode*)malloc(sizeof(ListNode));
	free(p1);
	ListNode* p2 = (ListNode*)operator new(sizeof(ListNode));
	operator delete(p2);
	void* p3 = malloc(0x7fffffff);
	if (p3 == NULL)
	{
		cout << "malloc fail" << endl;
	}
	void* p4 = operator new(0x7fffffff);
	ListNode* p5 = new ListNode(2);
	cout << "繼續(xù)" << endl;
}
//
//
int main()
{
	try
	{
		f();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

struct ListNode//目的是提高效率
{
	ListNode* _next;
	ListNode* _prev;
	int _val;
	// 類中重載專屬operator new
	void* operator new(size_t n)
	{
	void* p = nullptr;
	p = allocator<ListNode>().allocate(1);
	cout << "memory pool allocate" << endl;
	return p;
	}
	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}
	ListNode(int val)
		:_next(nullptr)
		, _prev(nullptr)
		, _val(val)
	{}
};
int main()
{
	ListNode* p = new ListNode(1);
	delete p;
	return 0;
}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* pa = (A*)operator new(sizeof(A));
	//pa->A();//error錯(cuò)誤調(diào)用方式，構(gòu)造函數(shù)只允許構(gòu)造時(shí)進(jìn)行調(diào)用
	new(pa)A; // 定位new，placement-new，顯示調(diào)用構(gòu)造函數(shù)初始化這塊對(duì)象空間
	A* pb = (A*)operator new(sizeof(A));
	new(pb)A(3);
    A* pc = new A;
	new(pc)A(3);
	// 等于 delete p
	pa->~A(); // 析構(gòu)函數(shù)可以顯示調(diào)用
	operator delete(pa);
	pb->~A();
	operator delete(pb);
    delete pc;
	return 0;
}