C/C++記憶體分布

讓我們先來看看下面這段代碼：

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof (int)* 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int)* 4);
	free(ptr1);
	free(ptr3);
}

你知道代碼中的各個部分分別存盤在記憶體中的哪一個區域嗎？

【說明】
?1、堆疊又叫堆疊，用于存盤非靜態區域變數/函式引數/回傳值等等，堆疊是向下增長的，
?2、記憶體映射段是高效的I/O映射方式，用于裝載一個共享的動態記憶體庫，用戶可使用系統介面創建共享記憶體，做行程間通信，
?3、堆用于存盤運行時動態記憶體分配，堆是向上增長的，
?4、資料段又叫靜態區，用于存盤全域資料和靜態資料，
?5、代碼段又叫常量區，用于存放可執行的代碼和只讀常量，

順便提一下：為什么說堆疊是向下增長的，而堆是向上增長的？

?簡單來說，在一般情況下，在堆疊區開辟空間，先開辟的空間地址較高，而在堆區開辟空間，先開辟的空間地址較低，

例如，下面代碼中，變數a和變數b存盤在堆疊區，指標c和指標d指向堆區的記憶體空間：

#include <iostream>
using namespace std;
int main()
{
	//堆疊區開辟空間，先開辟的空間地址高
	int a = 10;
	int b = 20;
	cout << &a << endl;
	cout << &b << endl;

	//堆區開辟空間，先開辟的空間地址低
	int* c = (int*)malloc(sizeof(int)* 10);
	int* d = (int*)malloc(sizeof(int)* 10);
	cout << c << endl;
	cout << d << endl;
	return 0;
}

?因為在堆疊區開辟空間，先開辟的空間地址較高，所以列印出來a的地址大于b的地址；在堆區開辟空間，先開辟的空間地址較低，所以c指向的空間地址小于d指向的空間地址，

注意：在堆區開辟空間，后開辟的空間地址不一定比先開辟的空間地址高，因為在堆區，后開辟的空間也有可能位于前面某一被釋放的空間位置，

C語言中動態記憶體管理方式

malloc、calloc、realloc和free
一、malloc

?malloc函式的功能是開辟指定位元組大小的記憶體空間，如果開辟成功就回傳該空間的首地址，如果開辟失敗就回傳一個NULL，傳參時只需傳入需要開辟的位元組個數，

二、calloc

?calloc函式的功能也是開辟指定大小的記憶體空間，如果開辟成功就回傳該空間的首地址，如果開辟失敗就回傳一個NULL，calloc函式傳參時需要傳入開辟的記憶體用于存放的元素個數和每個元素的大小，calloc函式開辟好記憶體后會將空間內容中的每一個位元組都初始化為0，

三、realloc

?realloc函式可以調整已經開辟好的動態記憶體的大小，第一個引數是需要調整大小的動態記憶體的首地址，第二個引數是動態記憶體調整后的新大小，realloc函式與上面兩個函式一樣，如果開辟成功便回傳開辟好的記憶體的首地址，開辟失敗則回傳NULL，

realloc函式調整動態記憶體大小的時候會有三種情況：
?1、原地擴，需擴展的空間后方有足夠的空間可供擴展，此時，realloc函式直接在原空間后方進行擴展，并回傳該記憶體空間首地址（即原來的首地址），
?2、異地擴，需擴展的空間后方沒有足夠的空間可供擴展，此時，realloc函式會在堆區中重新找一塊滿足要求的記憶體空間，把原空間內的資料拷貝到新空間中，并主動將原空間記憶體釋放（即還給作業系統），回傳新記憶體空間的首地址，
?3、擴充失敗，需擴展的空間后方沒有足夠的空間可供擴展，并且堆區中也沒有符合需要開辟的記憶體大小的空間，結果就是開辟記憶體失敗，回傳一個NULL，

四、free

?free函式的作用就是將malloc、calloc以及realloc函式申請的動態記憶體空間釋放，其釋放空間的大小取決于之前申請的記憶體空間的大小，

?若還想進一步了解malloc、calloc、realloc和free，請閱讀C語言動態記憶體管理，

C++中動態記憶體管理方式

?首先，C語言記憶體管理的方式在C++中可以繼續使用，但有些地方就無能為力而且使用起來比較麻煩，因此C++又提出了自己的記憶體管理方式：通過new和delete運算子進行動態記憶體管理，

new和delete操作內置型別

一、動態申請單個某型別的空間

	//動態申請單個int型別的空間
	int* p1 = new int; //申請
	
	delete p1; //銷毀

其作用等價于：

	//動態申請單個int型別的空間
	int* p2 = (int*)malloc(sizeof(int)); //申請

	free(p2); //銷毀

二、動態申請多個某型別的空間

	//動態申請10個int型別的空間
	int* p3 = new int[10]; //申請

	delete[] p3; //銷毀

其作用等價于：

	//動態申請10個int型別的空間
	int* p4 = (int*)malloc(sizeof(int)* 10); //申請
	
	free(p4); //銷毀

三、動態申請單個某型別的空間并初始化

	//動態申請單個int型別的空間并初始化為10
	int* p5 = new int(10); //申請 + 賦值

	delete p5; //銷毀

其作用等價于：

	//動態申請一個int型別的空間并初始化為10
	int* p6 = (int*)malloc(sizeof(int)); //申請
	*p6 = 10; //賦值

	free(p6); //銷毀

四、動態申請多個某型別的空間并初始化

	//動態申請10個int型別的空間并初始化為0到9
	int* p7 = new int[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; //申請 + 賦值

	delete[] p7; //銷毀

其作用等價于：

	//動態申請10個int型別的空間并初始化為0到9
	int* p8 = (int*)malloc(sizeof(int)* 10); //申請
	for (int i = 0; i < 10; i++) //賦值
	{
		p8[i] = i;
	}

	free(p8); //銷毀

注意：申請和釋放單個元素的空間，使用new和delete運算子；申請和釋放連續的空間，使用new[ ]和delete[ ]，

new和delete操作自定義型別

對于以下自定義型別：

class Test
{
public:
	Test() //建構式
		:_a(0)
	{
		cout << "建構式" << endl;
	}
	~Test() //解構式
	{
		cout << "解構式" << endl;
	}
private:
	int _a;
};

一、動態申請單個類的空間
用new和delete運算子：

	Test* p1 = new Test; //申請
	
	delete p1; //銷毀

用malloc和free函式：

	Test* p2 = (Test*)malloc(sizeof(Test)); //申請
	
	free(p2); //銷毀

二、動態申請多個類的空間
用new和delete運算子：

	Test* p3 = new Test[10]; //申請
	
	delete[] p3; //銷毀

用malloc和free函式：

	Test* p4 = (Test*)malloc(sizeof(Test)* 10); //申請
	
	free(p4); //銷毀

注意：在申請自定義型別的空間時，new會呼叫建構式，delete會呼叫解構式，而malloc和free不會，

總結一下：
?1、C++中如果是申請內置型別的物件或是陣列，用new/delete和malloc/free沒有什么區別，
?2、如果是自定義型別，區別很大，new和delete分別是開空間+建構式、解構式+釋放空間，而malloc和free僅僅是開空間和釋放空間，
?3、建議在C++中無論是內置型別還是自定義型別的申請和釋放，盡量都使用new和delete，

operator new和operator delete函式

?new和delete是用戶進行動態記憶體申請和釋放的運算子，operator new和operator delete是系統提供的全域函式，new和delete在底層是通過呼叫全域函式operator new和operator delete來申請和釋放空間的，
?operator new和operator delete的用法和malloc和free的用法完全一樣，其功能都是在堆上申請和釋放空間，

	int* p1 = (int*)operator new(sizeof(int)* 10); //申請
	
	operator delete(p1); //銷毀

其作用等價于：

	int* p2 = (int*)operator new(sizeof(int)* 10); //申請
	
	free(p2); //銷毀

?實際上，operator new的底層是通過呼叫malloc函式來申請空間的，當malloc申請空間成功時直接回傳；若申請空間失敗，則嘗試執行空間不足的應對措施，如果該應對措施用戶設定了，則繼續申請，否則拋例外，而operator delete的底層是通過呼叫free函式來釋放空間的，

注意：雖然說operator new和operator delete是系統提供的全域函式，但是我們也可以針對某個類，多載其專屬的operator new和operator delete函式，進而提高效率，

new和delete的實作原理

內置型別

?如果申請的是內置型別的空間，new/delete和malloc/free基本類似，不同的是，new/delete申請釋放的是單個元素的空間，new[ ]/delete [ ]申請釋放的是連續的空間，此外，malloc申請失敗會回傳NULL，而new申請失敗會拋例外，

自定義型別

new的原理
?1、呼叫operator new函式申請空間，
?2、在申請的空間上執行建構式，完成物件的構造，

delete的原理
?1、在空間上執行解構式，完成物件中資源的清理作業，
?2、呼叫operator delete函式釋放物件的空間，

new T[N]的原理
?1、呼叫operator new[ ]函式，在operator new[ ]函式中實際呼叫operator new函式完成N個物件空間的申請，
?2、在申請的空間上執行N次建構式，

delete[ ] 的原理
?1、在空間上執行N次解構式，完成N個物件中資源的清理，
?2、呼叫operator delete[ ]函式，在operator delete[ ]函式中實際呼叫operator delete函式完成N個物件空間的釋放，

定位new和運算式(placement-new)

?定位new運算式是在已分配的原始記憶體空間中呼叫建構式初始化一個物件，
使用格式：

new(place_address)type 或者 new(place_address)type(initializer-list)

?其中place_address必須是一個指標，initializer-list是型別的初始化串列，

使用場景：
?定位new運算式在實際中一般是配合記憶體池使用，因為記憶體池分配出的記憶體沒有初始化，所以如果是自定義型別的物件，就需要使用定位new運算式進行顯示呼叫建構式進行初始化，

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0) //建構式 
		:_a(a)
	{}

	~A() //解構式
	{}
private:
	int _a;
};
int main()
{
	//new(place_address)type 形式
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;

	//new(place_address)type(initializer-list) 形式
	A* p2 = (A*)malloc(sizeof(A));
	new(p2)A(2021);

	//解構式也可以顯示呼叫
	p1->~A();
	p2->~A();
	return 0;
}

注意：在未使用定位new運算式進行顯示呼叫建構式進行初始化之前，malloc申請的空間還不能算是一個物件，它只不過是與A物件大小相同的一塊空間，因為建構式還沒有執行，

常見面試題

malloc/free和new/delete的區別？

共同點：
?都是從堆上申請空間，并且需要用戶手動釋放，
不同點：

?1、malloc和free是函式，new和delete是運算子，
?2、malloc申請的空間不會初始化，new申請的空間會初始化，
?3、malloc申請空間時，需要手動計算空間大小并傳遞，new只需在其后跟上空間的型別即可，
?4、malloc的回傳值是void*，在使用時必須強轉，new不需要，因為new后跟的是空間的型別，
?5、malloc申請失敗時，回傳的是NULL，因此使用時必須判空，new不需要，但是new需要捕獲例外，
?6、申請自定義型別物件時，malloc/free只會開辟空間，不會呼叫建構式和解構式，而new在申請空間后會呼叫建構式完成物件的初始化，delete在釋放空間前會呼叫解構式完成空間中資源的清理，

記憶體泄漏

什么是記憶體泄漏，記憶體泄漏的危害？

記憶體泄漏：

?記憶體泄漏是指因為疏忽或錯誤造成程式未能釋放已經不再使用的記憶體的情況，記憶體泄漏并不是指記憶體在物理上的消失，而是應用程式分配某段記憶體后，因為設計錯誤，失去了對該段記憶體的控制，因而造成了記憶體的浪費，

記憶體泄漏的危害：

?長期運行的程式出現記憶體泄漏，影響很大，如作業系統、后臺服務等等，出現記憶體泄漏會導致回應越來越慢，最終卡死，

void MemoryLeaks()
{
	// 1.記憶體申請了忘記釋放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.例外安全問題
	int* p3 = new int[10];
	Func(); // 這里Func函式拋例外導致 delete[] p3未執行，p3沒被釋放.
	delete[] p3;
}

記憶體泄漏分類？

在C/C++中我們一般關心兩種方面的記憶體泄漏：
1、堆記憶體泄漏(Heap Leak)

?堆記憶體指的是程式執行中通過malloc、calloc、realloc、new等從堆中分配的一塊記憶體，用完后必須通過呼叫相應的free或者delete釋放，假設程式的設計錯誤導致這部分內容沒有被釋放，那么以后這部分空間將無法再被使用，就會產生Heap
Leak，

2、系統資源泄漏

?指程式使用系統分配的資源，比方套接字、檔案描述符、管道等沒有使用對應的函式釋放掉，導致系統資源的浪費，嚴重可導致系統效能減少，系統執行不穩定，

如何避免記憶體泄漏？

?1、工程前期良好的設計規范，養成良好的編碼規范，申請的記憶體空間記住匹配的去釋放，
?2、采用RALL思想或者智能指標來管理資源，
?3、有些公司內部規范使用內部實作的私有記憶體管理庫，該庫自帶記憶體泄漏檢測的功能選項，
?4、出問題了使用記憶體泄漏工具檢測，

記憶體泄漏非常常見，解決方案分為兩種：
?1、事前預防型，如智能指標等，
?2、事后查錯型，如泄漏檢測工具，

如何一次在堆上申請4G的記憶體？

在堆上申請4G的記憶體：

#include <iostream>
using namespace std;
int main()
{
	//0xffffffff轉換為十進制就是4G
	void* p = malloc(0xfffffffful);
	cout << p << endl;

	return 0;
}

?在32位的平臺下，記憶體大小為4G，但是堆只占了其中的2G左右，所以我們不可能在32位的平臺下，一次性在堆上申請4G的記憶體，這時我們可以將編譯器上的win32改為x64，即64位平臺，這樣我們便可以一次性在堆上申請4G的記憶體了，