系列文章目錄

前言

一、C/C++記憶體分布

代碼如下
我們先來看下面的一段代碼和相關問題:

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
#include<string.h>
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);
	
	std::cout << "sizeof(num1):" <<sizeof(num1) << std::endl;
	std::cout << "sizeof(char2):"<<sizeof(char2) << std::endl;
	std::cout << "strlen(char2):" << strlen(char2) << std::endl;
	std::cout << "sizeof(pChar3):" << sizeof(pChar3) << std::endl;
	std::cout << "strlen(pChar4):" << strlen(pChar3) << std::endl;
	std::cout << "sizeof(ptr1):" << sizeof(ptr1) << std::endl;
}
int main()
{
	Test();
	return 0;
}

記住： sizeof是一個C語言中的一個單目運算子，而strlen是一個函式，用來計算字串的長度，sizeof求的是資料型別所占空間的大小，而strlen是求字串的長度,strlen(結束的標志是是否碰到\0)，

• 說明：
• 堆疊又叫堆疊，非靜態區域變數/函式引數/回傳值等等，堆疊是向下增長的，
• 記憶體映射段是高效的I/O映射方式，用于裝載一個共享的動態記憶體庫，用戶可使用系統介面創建共享共享記憶體，做行程間通信，（Linux課程如果沒學到這塊，現在只需要了解一下），
• 堆用于程式運行時動態記憶體分配，堆是可以上增長的，
• 資料段–存盤全域資料和靜態資料，
• 代碼段–可執行的代碼/只讀常量，

解釋堆疊為啥是向下生長，堆是向上生長，

• 堆疊向下生長是因為在堆疊區開辟的空間是先開辟的空間在高地址，后開辟的空間在低地址，

代碼如下

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
int main()
{
	int a = 1;
	int b = 2;
	std::cout << &a << std::endl;
	std::cout << &b << std::endl;
	return 0;
}

• 堆向上生長是因為在堆區開辟空間先開辟的空間在低地址，后開辟的空間在高地址，

代碼如下

	int* c = (int*)malloc(sizeof(int));
	int* d = (int*)malloc(sizeof(int));
	std::cout << c << std::endl;
	std::cout << d << std::endl;

注意:在堆疊區后一個開辟的空間的地址不一定比前面先開辟空間的地址大，因為可能后開辟空間的地址是在前面釋放的空間上開辟的地址，

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

1.malloc/calloc/realloc和free

代碼如下

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
// 1.malloc/calloc/realloc的區別是什么
int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)calloc(4,sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	free(p1);
	//free(p2); // 這里需要free(p2)嗎？
	free(p3);
	return 0;
}

注意：如果此時你在p2的基礎上擴容，則p2則不需要自己釋放，否則會發生錯誤，

• 【面試題】
  malloc/calloc/realloc的區別？
  
  原地擴容：需要擴容的空間后面有充足的空間可以擴容，realloc函式直接在原來的空間后方進行擴容，成功則回傳該記憶體空間首地址（即原來的首地址），
  
  異地擴容：需要擴容的空間后方并沒有足夠的空間可供擴容，那么，realloc函式會在堆區中再找一塊滿足大小的記憶體空間然后將原來空間內的資料拷貝到新空間中，在主動將原空間記憶體釋放（即還給作業系統），不需要自己手動free原有空間，否則會發生錯誤，最后回傳新記憶體空間的首地址，
  
  擴容失敗：此時堆空間中沒有足夠的空間來擴容，此時就是擴容失敗，回傳NULL，

三、C++中動態記憶體管理

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

1.new/delete操作內置型別

代碼如下

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
int main()
{
	int* p1 = new int;                        //C++動態的申請一個int型別的空間
	int* p2 = (int*)malloc(sizeof(int*));     //C動態申請一個int型別的空間
	delete p1;
	free(p2);

	int* p3 = new int[10];                    //C++動態申請10個int型別的空間
	int* p4 = (int*)malloc(sizeof(int*)* 10); //C動態申請1個int型別的空間
	delete[] p3;
	free(p4);

	int* p5 = new int(1);                      //C++動態申請1個int型別的空間并且初始化為1
	int* p6 = new int[3]{1, 2, 3};             //C++動態申請3個int型別的空間并且初始化
	delete p5;
	delete[] p6;
	return 0;
}

new/delete和malloc/free 針對內置型別沒有任何差別，只是用法不一樣，
代碼如下

void Test()
{
    //new/delete和malloc/free 針對內置型別沒有任何差別，只是用法不一樣
	// 動態申請一個int型別的空間
	int* ptr4 = new int;
	// 動態申請一個int型別的空間并初始化為10
	int* ptr5 = new int(10);
	// 動態申請10個int型別的空間
	int* ptr6 = new int[3];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

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

2.new和delete操作自定義型別

代碼如下

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
class Test
{
public:
	Test()
		:_data(0)
	{
		std::cout << "Test():" << std::endl;
	}
	~Test()
	{
		std::cout << "~Test():" << std::endl;
	}
private:
	int _data;
};
void Test2()
{
	//申請一個Test型別的空間
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	//申請十個Test型別的空間
	Test* p2 = (Test*)malloc(sizeof(Test)* 10);
	free(p2);
}
void Test3()
{
	//申請一個Test型別的物件
	Test* p1 = new Test;

	//申請10個Test型別的物件
	Test* p2 = new Test[10];
}
int main()
{
	Test T;
	Test3();
	return 0;
}

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

四、operator new與operator delete函式

1.operator new與operator delete函式（重點）

new和delete是用戶進行動態記憶體申請和釋放的運算子，operator new 和operator delete是系統提供的全域函式，new在底層呼叫operator new全域函式來申請空間，delete在底層通過operator delete全域函式來釋放空間，

• 實際上 operator new和operator delete的用法跟malloc和free是完全是一樣的功能，都是在堆上申請釋放空間,但是失敗了處理方式不一樣，malloc失敗回傳NULL，operator new失敗以后拋例外，

代碼如下

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
int main()
{
	//以下三種方式開辟空間和釋放空間的效果是一樣的
	int* p1 = (int*)malloc(sizeof(int));      //malloc和free
	free(p1);

	int* p2 = new int;                        //new和delete
	delete p2;

	int* p3 = (int*)operator new(sizeof(int));//operator new與operator delete
	operator delete (p3);
	return 0;
}

2.operator new失敗拋例外機制

operator new失敗了處理方式不一樣，malloc失敗回傳NULL，operator new失敗以后拋例外，
代碼如下

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
using namespace std;
void f()
{
	// 他的用法跟malloc和free是完全一樣的，功能都是在堆上申請釋放空間
	// 失敗了處理方式不一樣，malloc失敗回傳NULL，operator new失敗以后拋例外
	void* p3 = malloc(0x7fffffff);
	if (p3 == NULL)
	{
		cout << "malloc fail" << endl;
	}
	void* p4 = operator new(11);
	char* p5 = new char[0x7fffffff];
	cout << "繼續" << endl;
}
int main()
{
	try
	{
		f();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

operator new與operator delete底層原始碼

/*
operator new：該函式實際通過malloc來申請空間，當malloc申請空間成功時直接回傳；申請空間失敗，
嘗試執行空 間不足應對措施，如果改應對措施用戶設定了，則繼續申請，否則拋例外，
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void *p;
	while ((p = malloc(size)) == 0)
	if (_callnewh(size) == 0)
	{
		// report no memory
		// 如果申請記憶體失敗了，這里會拋出bad_alloc 型別例外
		static const std::bad_alloc nomem;
		_RAISE(nomem);
	}
	return (p);
}
/*
operator delete: 該函式最終是通過free來釋放空間的
*/
void operator delete(void *pUserData)
{
	_CrtMemBlockHeader * pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}
/*
free的實作
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

• 通過上述兩個全域函式的實作知道，operator new 實際也是通過malloc來申請空間，如果malloc申請空間成功就直接回傳，否則執行用戶提供的空間不足應對措施，如果用戶提供該措施就繼續申請，否則就拋例外，operator delete 最終是通過free來釋放空間的，

3.operator new與operator delete的類專屬多載（了解）

寫了類專屬多載就不用呼叫全域的operator new與Operator delete，

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;
}

沒有寫operator new與operator delete，

五、new和delete的實作原理

1.內置內型

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

2.自定義型別

1.new的原理

• 呼叫operator new函式申請空間
• 呼叫operator new函式申請空間

2.delete的原理

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

3.new T[N]的原理

• 呼叫operator new[]函式，在operator new[]中實際呼叫operator new函式完成N個物件空間的申請，
• 在申請的空間上執行N次建構式，

4.delete T[N]的原理

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

六、定位new運算式(placement-new)（了解）

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

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

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}

private:
	int _a;
};
int main()
{
	// p現在指向的只不過是與A物件相同大小的一段空間，還不能算是一個物件，因為建構式沒有執行

	// A* p = (A*)malloc(sizeof(A));
	// 等價于直接用A* p = new A
	
	A* p = (A*)operator new(sizeof(A));
	new(p)A; // new(p)A(3);  // 定位new，placement-new，顯示呼叫建構式初始化這塊物件空間

	// 等于 delete p
	p->~A(); // 解構式可以顯示呼叫
	operator delete(p);
	return 0;
}

七、常見面試題

1. malloc/free和new/delete的區別

• malloc/free和new/delete的共同點是：都是從堆上申請空間，并且需要用戶手動釋放，
• 不同的地方是：
• malloc和free是函式，new和delete是運算子，
• malloc申請的空間不會初始化，new可以初始化，
• malloc申請的空間不會初始化，new可以初始化，
• malloc的回傳值為void*, 在使用時必須強轉，new不需要，因為new后跟的是空間的型別，
• malloc申請空間失敗時，回傳的是NULL，因此使用時必須判空，new不需要，但是new需要捕獲例外，
• 申請自定義型別物件時，malloc/free只會開辟空間，不會呼叫建構式與解構式，而new在申請空間后會呼叫建構式完成物件的初始化，delete在釋放空間前會呼叫解構式完成空間中資源的清理，

2. 記憶體泄漏

1.記憶體泄漏概念與危害

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

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

代碼如下：

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;
}

2.記憶體泄漏分類（了解）

C/C++程式中一般我們關心兩種方面的記憶體泄漏：

• 堆記憶體泄漏(Heap leak)
  堆記憶體指的是程式執行中依據須要分配通過malloc / calloc / realloc / new等從堆中分配的一塊記憶體，用完后必須通過呼叫相應的 free或者delete 刪掉，假設程式的設計錯誤導致這部分記憶體沒有被釋放，那么以后這部分空間將無法再被使用，就會產生Heap Leak，
• 系統資源泄漏
  指程式使用系統分配的資源，比方套接字、檔案描述符、管道等沒有使用對應的函式釋放掉，導致系統資源的浪費，嚴重可導致系統效能減少，系統執行不穩定，

3.如何檢測記憶體泄漏（了解）

• 在linux下記憶體泄漏檢測：Linux下幾款記憶體泄露檢測工具
• 在windows下使用第三方工具：VLD工具說明
• 其他工具：記憶體泄露工具比較

4.如何避免記憶體泄漏

• 工程前期良好的設計規范，養成良好的編碼規范，申請的記憶體空間記著匹配的去釋放，ps：這個理想狀態，但是如果碰上例外時，就算注意釋放了，還是可能會出問題，需要下一條智能指標來管理才有保證，
• 采用RAII思想或者智能指標來管理資源，
• 出問題了使用記憶體泄漏工具檢測，ps：不過很多工具都不夠靠譜，或者收費昂貴，

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

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

當我們想在win32平臺上堆上想開辟4G的記憶體空間0xffffffff的時候會發生錯誤，
代碼如下：

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
using namespace std;
int main()
{
	//1byte == 8bit
	//	1KB = 1024byte
	//	1MB = 1024KB
	//	1GB = 1024MB
	//	1TB = 1024GB
	void* p1 = malloc(0xffffffff);
	cout << p1 << endl;
	return 0;
}

那如何在堆上開辟4G的空間呢？
因為32位的平臺下，記憶體大小為4G，但是堆區差不多2G，所以不可能在32位的平臺上一次在堆上開辟4G的記憶體，但是我們可以將編譯器上的win32改為x64，在64位平臺下，我們便可以一次性在堆上申請4G的記憶體了，

總結

以上就是今天要講的內容，本文僅僅簡單介紹了C、C++記憶體管理的使用，而new、delete提供了快速能使我們快速便捷創建物件，而且還能呼叫建構式與解構式，非常的便捷，所以我們務必掌握，到現在，記憶體管理已經完畢，接下就是STL的重頭戲，另外如果上述有任何問題，請懂哥指教，不過沒關系，主要是自己能堅持，更希望有一起學習的同學可以幫我指正，但是如果可以請溫柔一點跟我講，愛與和平是永遠的主題，愛各位了，