C語言動態記憶體管理及使用總結篇【初學者保姆級福利】

動態記憶體管理及應用總結篇
一篇博客學好動態記憶體的管理和使用
這篇博客干貨滿滿，建議收藏再看哦！！
求個贊求個贊求個贊求個贊 謝謝🙏

先贊后看好習慣 打字不容易，這都是很用心做的，希望得到支持你 大家的點贊和支持對于我來說是一種非常重要的動力 看完之后別忘記關注我哦！???
本篇基本上涵蓋了初學階段動態記憶體的所有知識點，喜歡的伙伴一定要看完哦

本章重點
動態記憶體函式介紹
動態記憶體常見錯誤及其避免
柔性陣列

動態記憶體函式介紹

想要學習動態記憶體分配，我們一定要知道，動態記憶體是怎么開辟的，是怎么釋放的，

malloc()和free()

malloc()的原型void* malloc (size_t size);
使用malloc函式，我們可以直接在堆上申請我們想要大小的空間，
注意，用malloc()開辟的空間，是在記憶體的堆上的，而不是堆疊上的
如果malloc()開辟空間成功，會回傳新開辟空間的地址，如果開辟失敗，會回傳空指標，
每次使用完在堆上開辟的空間后，一定要記得釋放剛剛的空間，把它還給計算機，用的是free()函式，

int main()
{
	int*p=(int*)malloc(10 * sizeof(int));//堆區開辟空間 
	//但是void*是不能解參考的
	//使用這些空間之前，一定要記得檢驗malloc()是否開辟空間成功
	if (p == NULL)
	{
		perror("main");
		return 1;//結束函式
	}
	//使用
	//...
	//回收空間
	free(p);
	//但是p是不會自動把p置成NULL？
	//答案是不會，為了防止以后非法訪問
	p = NULL;//自己動手把p置成NULL
	return 0;
}

這就是用malloc()開辟空間，使用完用free()釋放空間的一個標準的使用模板
以下是一些需要注意的點，
1.使用malloc()堆上空間之后，一定要記得檢驗是否開辟失敗，否則可能將會造成對空指標解參考的問題，
2.使用完堆上空間后，一定要記得用free()函式釋放，把空間還給記憶體，
注意：free()只能釋放動態開辟的空間，也就是堆上的空間，不能用來釋放堆疊上的空間

int main()
{
	int a = 10;
	free(&a);//錯誤
	return 0;
}

所以綜上：malloc()和free()要成對使用

calloc()

先來看函式原型：void* calloc (size_t num, size_t size);
我們打開www.cplusplus.com可以看到
該函式的作用是Allocate and zero-initialize array也就是在堆上開辟一個初始化為0的一個陣列
兩個引數分別是，想要開辟的元素個數，和每個元素的大小

int main()
{
	int* p = (int*)calloc(10,sizeof(int));
	if (p == NULL)//檢驗是否開辟成功
	{
		perror("main");
		return 1;
	}
//使用程序
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i)=5;
	}
	//回收空間
	free(p);
	p=NULL;
	return 0;
}

與malloc()不同的是，calloc()函式開辟的空間已經初始化為0了，而malloc()開辟的空間是沒有初始化的，我們可以自己寫一段小代碼，f10運行后打開記憶體視窗就可以看到了

realloc()

realloc函式的功能是，Changes the size of the memory block pointed to by ptr.也就是改變空間的 大小
先來看realloc函式的原型：void* realloc (void* ptr, size_t size);
第一個引數就是指向一塊兒動態記憶體的指標，第二個引數就是想要設定的該空間的新大小，
我們在剛才上面這段代碼的基礎上，講解我們的realloc()函式

int main()
{
	//int* p = (int*)malloc(40);//還沒初始化
	int* p = (int*)calloc(10,sizeof(int));//初始化了
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i)=5;
	}
	//還想再來十個整型的地址
	//realloc來調整空間
	int*ptr=(int*)realloc(p, 20 * sizeof(int));
	//追加空間
	//判斷追加的空間是否追加成功
	if (ptr != NULL)
	{
		p = ptr;
	}
    //使用
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//釋放空間
	free(p);
	p = NULL;
	return 0;
}

然而，我們需要掌握的realloc()的使用和理解并不只是這么簡單
使用realloc()追加空間的時候常常會有以下這幾種情況

1.如果realloc()發現原來p指向的空間后面空間足夠——直接增容并且回傳原地址
2.如果realloc()發現p指向的空間后面的空間不夠的時候，
  它會重新找一塊新的空間，
  并且把原來的內容拷貝下來，放到新找到的空間里面去，
  并且把舊地址釋放，
  3.如果在整個堆區里面找不到合適空間的時候，就回傳空指標，

所以需要注意的是：
	一般不能直接用原來的p來接受realloc()的回傳值，
	萬一堆里找不到空間，還把原來的p搞沒了
	如果這樣，我們就永遠找不到一開始開辟的空間了
	所以一般創建一個臨時指標int*ptr來接收realloc()函式的回傳值
	并且判斷開辟成功以后，再把ptr賦給p即可，

動態記憶體使用常見錯誤及其避免

關注過我的小伙伴知道，我已經在發布這篇博客之前已經發過一篇動態記憶體的避雷篇了，跟以下內容是一樣的，小伙伴們可以去我的另外一篇博客了解這部分內容，也可以在這里繼續往下看哦

對空指標的非法解參考

一般來說，有一定基礎的我們都不會故意解參考空指標，但是，我們在使用動態記憶體開辟的時候，可能會解參考到”無形“的空指標

int main()
{
	int*p=(int*)malloc(10000000000000000000);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;//err
	}
	return 0;
}

在上面這個代碼中，看似沒有什么問題，但是我們知道malloc函式是有可能開辟動態記憶體空間失敗的，我們一口氣開辟這么多位元組的空間，我們堆上空間不夠用了，malloc函式就會開辟失敗，我們通過www.cplusplus.com網站搜索malloc函式我們可以知道，如果函式開辟失敗，會回傳空指標，那么這個時候，我們的p就是一個空指標，空指標怎么能解參考呢？
我們可以在for之前用一個perror()函式來查看我們的問題perror("main:");

為了避免在撰寫程式的時候遇到這個問題，我們可以用assert()斷言后再使用該指標，或者使用if陳述句，當指標為真的時候再使用該指標

越界訪問問題

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	//越界訪問，我們只開辟了40個位元組，不是四十個整型
	for (i = 0; i < 40; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

正如這個代碼，我們必須知道malloc函式在堆上開辟的時候的單位是位元組，而我們這里卻要訪問40個整型，也就是160個位元組，這就越界訪問了
每寫一步我們思考清楚就可以避免這個問題，

使用free釋放非動態開辟的空間

free只能用來釋放堆上的動態開辟的空間，而不能釋放堆疊上的空間，堆疊上的記憶體空間，在函式結束，程式結束都會自動釋放的，

//3.使用free釋放非動態開辟的空間
int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	free(p);//err
	p = NULL;
	return 0;
}

每寫一步我們思考清楚就可以避免這個問題，

使用free釋放動態記憶體中的一部分

釋放了，但沒完全釋放

//4.使用free釋放動態記憶體中的一部分
int main()
{
	int* p = malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p++ = i;//我的p不見了
	}
	free(p);//err
	p = NULL;
	return 0;
}

*在這個代碼中，由p指標指向的動態記憶體開辟后，我們的p在后續操作中改變了它自己的值，這意味這什么？
這代表沒東西再可以找到這塊空間了，我們到時候free§只是free()掉了p后面的一些空間，那么p前面的空間呢？不管了？
所以如果p這個位置改變了，找不到了是一件很可怕的事情，

那么，我們如何避免呢？
如果在后續我們要操作p，我們一開始就要用另一個的指標變數來記錄我一開始p的位置，最后free()這個記錄起始位置的指標變數，這樣就可以避免“free()了，但沒完全free()的問題”

對同一塊動態開辟的空間，多次釋放的問題

//5.對同一塊動態開辟的空間，多次釋放
int main()
{
	int* p = (int*)malloc(100);
	//使用
	//...
	free(p);//萬一一個在函式里面，沒發現，就會出現這種情況

	//
	free(p);
	return 0;
	//所以這個時候，我們需要再free完，立刻把p置為空指標
	//這樣的話，第二次呼叫free()的時候，傳空指標，什么事情都不會發生
}

看到這里，有些伙伴可能會問：我肯定不會兩個free寫在一起啊
這里其實只是比較明顯而已，如果在函式里面，已經free了，后面又寫了很多代碼，最后想起來又free一次，這樣就會出現這種問題了
為了避免這個問題，我們一定要主動地在free()之后，馬上把我們的p置空：p=NULL；這樣我們后面就算在free(),free()函式傳NULL給它的時候，是不會有任何問題的，

動態開辟的空間忘記釋放（比較嚴重的問題）

//6.動態開辟的空間忘記釋放
void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return;
	}
	//使用
	//忘記釋放了
	// 
	// 
	// 
	//當我們出函式的時候，p會自動釋放，那沒人可以找到那塊在堆上的空間了
	//如果return以后，就沒有人可以找到p指向的空間了
	//這樣會造成記憶體泄露
}
int main()
{
	test();
	return 0;
}

我們在前面介紹部分釋放這個問題的時候已經知道，不free()會造成記憶體泄漏
在這里，我來為大家總結一下堆上動態開辟的空間的兩種釋放方式
1.程式員代碼主動釋放，即呼叫free()函式
2.程式結束
在我們一開始使用動態記憶體的階段，這個問題可能看似沒那么嚴重，程式好像照樣跑，反正泄露一點也沒關系，程式結束它就自動釋放了
但如果我們這是一個服務器的程式呢，24小時跑呢，假如記憶體只有32個g，每天泄露一點，那機器不就越來越卡了？，最后只會卡死，卡死了就重啟，又卡死，再重啟，這種問題就會對我們的機器的使用造成很大困擾，所以記憶體泄漏其實是一個比較嚴重的問題，所以我們一定要記得free().

柔性陣列

雖然柔性陣列這個概念在我們的使用中并不常見，但是也是我們要掌握的要點之一
C99中，結構體中的最后一個元素允許是未知大小的陣列，這就叫柔性陣列成員

struct S
{
	int n;
	int arr[];//大小是未知的
	//int arr[0];也可以
};

此處的arr[]就是一個柔性陣列，大小未知，
那我們如何去使用它呢

struct S
{
	int n;
	int arr[];//大小是未知的
	//int arr[0];也可以
};
int main()
{
	//期望arr的大小是10個整型
	struct S*ps=(struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	ps->n = 10;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	//包含柔性陣列的結構，統一用malloc來開辟空間
	//增加
	struct S*ptr=realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	//增加到20個
	if (ptr != NULL)
	{
		ps = ptr;
	}
	//使用
	//......
	//釋放
	free(ps);
	ps = NULL;
	return 0;
}

注意的點： 1.包含柔性陣列的結構體，統一用malloc()來開辟空間 2.開辟空間之前，我們要有一個柔性陣列期望的大小，就是我們大概想要用多少，我們是要清楚的

模擬實作柔性陣列

我們知道，既然我們在結構體內部定義arr[]的時候，我們是不用定義陣列大小的，而與此同時陣列名又是首元素地址，那么我們為什么不把結構體里面的int arr[];直接寫成int*arr;?
使用這種定義方法，arr已經不在是柔性陣列了，但是，為了模擬柔性陣列的功能，我們可以讓arr的空間在堆上開辟

struct S
{
	int n;
	int* arr;
};
//我們要保證我們的n，arr指向的空間，都要是在堆上開辟
int main()
{
	struct S*ps=(struct S*)malloc(sizeof(struct S));
	//先開辟一塊給struct S
	if (ps == NULL)
	{
		return 1;
	}
	//再找一個指標指向arr
	//剛才那個指標ps是指向整個結構體S的
	//現在搞一個指標指向arr
	//有了這個指標arr，我們就可以操作這個陣列了
	ps->arr =(int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
	{
		return 1;
	}


    //使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	//增加
	int*ptr=realloc(ps->arr, 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	//釋放的時候一定要先釋放arr，再釋放ps
	//如果先釋放ps，那么arr就找不到了
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

需要注意的點：1.要想實作柔性陣列的功能，必須在堆上為arr開辟空間，不能在堆疊上開辟， 2.我們要使用ps->arr這個指標來操作陣列 3.釋放空間的時候，一定要先釋放arr，再釋放ps，為什么？因為ps一旦釋放，就沒有東西可以找到arr了，會造成記憶體泄漏
以上兩種方式，第一種是柔性陣列的運用
第二種不是，只是一種用指標的方式，實作相當于柔性陣列的功能
但是再相比之下，第一種，使用柔性陣列的方式更加好、
因為第二種有兩次malloc()，對應著兩次free()，更容易出錯
如果頻繁使用記憶體塊，會導致效率降低
多次malloc()并不是一件好的事情

尾聲

能看到這里的小伙伴，如果你已經完全理解了這篇博客的內容，相信你對動態記憶體的理解已經提高了一個層次了如果感覺這篇博客對你有幫助的話，別忘了你的贊，收藏和關注哦