C++的動態記憶體管理你真的瞭解嗎

#include <iostream>
using namespace std;
int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int) * 10);
	//new後面跟動態申請的型別
	int* p3 = new int;//動態申請一個int型空間
	int* pp3 = new int(1);//動態申請一個int型空間並初始化為1
	//動態申請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;	//申請空間並呼叫建構函式初始化
	delete p3;
	// 申請10個Test型別的物件
	Test* p4 = new Test[10];//申請空間並呼叫建構函式初始化
	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("executen");
	return 0;
}

#include <iostream>
using namespace std;
int main()
{	
	try    //檢測異常
	{
		char* p = new char[1024u * 1024u * 1024u * 2 - 1];  //new失敗，直接跳到catch，不執行下面語句
		printf("executen");
	}
	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中的記憶體池
		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;};//建構函式是不支援直接手動呼叫的，所以引入定位new，對已經存在的物件呼叫建構函式初始化，常用於記憶體池中的物件int main(){//呼叫operator new申請空間，operator new和malloc函數用法類似Test* p = (Test*)operator new(sizeof(Test));//呼叫建構函式初始化new(p)Test(1);//定位new，new後面接要初始化物件的地址+型別，(1)表示初始化為1//先呼叫解構函式，解構函式可以直接呼叫p->~Test();//在呼叫operator delete釋放空間operator delete (p);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;
};
//建構函式是不支援直接手動呼叫的，所以引入定位new，對已經存在的物件呼叫建構函式初始化，常用於記憶體池中的物件
int main()
{	
//呼叫operator new申請空間，operator new和malloc函數用法類似
	Test* p = (Test*)operator new(sizeof(Test));
	//呼叫建構函式初始化
	new(p)Test(1);	//定位new，new後面接要初始化物件的地址+型別，(1)表示初始化為1
	//先呼叫解構函式，解構函式可以直接呼叫
	p->~Test();
	//在呼叫operator delete釋放空間
	operator delete (p);

	return 0;
}