C語言動態內存分配篇

目錄

一、為什么存在動態內存管理/分配？

????????內存的存儲形式劃分

二、動態內存函數的介紹

????????malloc

????????free

????????malloc和free的實際應用

????????calloc

????????realloc

三、常見的動態內存錯誤

????????對NULL指針的解引用操作

????????對動態開辟的空間越界訪問

????????對非動態開辟內存使用 free 釋放

????????使用 free 釋放一塊動態開辟內存的一部分

????????對同一塊動態內存的多次釋放

????????動態開辟內存忘記釋放（導致內存泄露）

四、C/C++程序的內存開辟

五、柔性數組

????????柔性數組的特點

????????柔性數組的使用

????????柔性數組的優勢

一、為什么存在動態內存管理/分配？

（1）因為內存太寶貴。

（2）如果全部是靜止內存不能釋放，對于小的程序可以運行完畢。但是對于大的程序，還沒運行完，內存就要被占用完，此時就要發生內存泄露。

（3）假設給定一個占用內存可變大小的變量（假設是數組的長度len），那么給該變量通過函數動態分配內存后，分配內存的大小是根據數組的長度len決定的。假定用戶輸入len的大小是5，系統就會動態的給該數組分配長度為5的內存。? 該段代碼運行結束后，系統調用free()函數釋放分配的內存，然后接著運行剩下的程序。

換句話說，動態分配內存可以根據需要去申請內存，用完后就還回去，讓需要的程序用。

我們先看個例子：

int a = 20;        //局部變量 在棧區上開辟四個字節char ch[10] = {0}; //局部變量 在棧空間上開辟10個字節的連續空間int g_a = 10;      //全局變量 在靜態區上開辟十個字節

上述的開辟空間的方式有兩個特點：

1. ?空間開辟大小是固定的。
2. ?數組在申明的時候，必須指定數組的長度，它所需要的內存在編譯時分配。

但是對于空間的需求，不僅僅是上述的情況。有時候我們需要的空間大小在程序運行的時候才能知道，那數組的編譯時開辟空間的方式就不能滿足了。 這時候就只能試試動態存開辟了。?

內存的存儲形式劃分

二、動態內存函數的介紹

? ?malloc

• 專門用來動態內存開辟的函數

//函數原型void *malloc (size_t size);//void*  表示任意類型的指針//size_t 表示的是unsigned int(無符號整型)//size   表示所要開辟的空間單位是字節

這個函數向內存申請一塊連續可用的空間，并返回指向這塊空間的指針。

• 如果開辟成功，則返回一個指向開辟好空間的指針。
• 如果開辟失敗，則返回一個NULL指針，因此 malloc 的返回值一定要做檢查。
• 返回值的類型是 void* ，所以 malloc 函數并不知道開辟空間的類型，具體在使用的時候使用者自己來決定。
• 如果參數 size 為 0 ，malloc 的行為是標準是未定義的，取決于編譯器。

? ?free

• 專門用來做動態內存的釋放和回收的函數

//函數原型void free(void *ptr);//void *prt 表示所要釋放的指針類型

free函數用來釋放動態開辟的內存。

• 如果參數 ptr 指向的空間不是動態開辟的，那 free 函數的行為是未定義的。
• 如果參數 ptr 是NULL指針，則函數什么事都不做。

?malloc和free的實際應用

代碼如下：

#include #include #include int main(){	//1.通過動態開辟申請10個int類型的空間	//根據實際使用強制類型轉換為想要的類型	int *p = (int*)malloc(10 * sizeof(int));	//2.malloc有可能申請空間失敗，所以需要判斷一下	if (p == NULL)//判斷p指針是否為空	{		printf("%s/n", strerror(errno));	}	else	{		//正常使用空間		int i = 0;		for (i = 0; i < 10; i++)		{			*(p + i) = i;		}		for (i = 0; i < 10; i++)		{			printf("%d ", *(p + i));		}	}	//當動態申請的空間不再使用的時候，就應該還給操作系統	free(p);//釋放p所指向的動態內存	p = NULL;//是否有必要	return 0;}

執行結果：

思考：

p = NULL;?是否有必要加上？

解答：

由于 free 完后本身是不會置為空指針的，因此我們需要手動將其變為空指針，所以p = NULL是有必要的。

? ?calloc

• 能夠讓動態分配在申請空間的同時就進行初始化的函數

//函數原型void *calloc(size_t num, size_t size);//

• 函數的功能是為 num 個大小為?size 的元素開辟一塊空間，并且把空間的每個字節初始化為?0?。
• 與函數 malloc 的區別只在于 calloc 會在返回地址之前把申請的空間的每個字節初始化為全 0 。

例：

#include #include #include int main(){	int *p = (int*)calloc(10, sizeof(int));	if(p == NULL)	{		printf("%s/n", strerror(errno));	}	else	{		int i = 0;		for(i = 0; i < 10; i++)		{			printf("%d ", *(p + i));		}	}	//free函數用來釋放動態開辟的空間	free(p);	p = NULL;	return 0;}

執行結果：

總結：所以如何我們對申請的內存空間的內容要求初始化，那么可以很方便的使用 calloc 函數來完成任務。而 calloc 函數會將所申請到的內存空間全部初始化成 0?，意味著 calloc 比 malloc 運行時間更長，所以在選擇這兩個函數時可以根據是否需要初始化來選擇。

? ?realloc

• 能夠將動態內存靈活分配的函數
• 有時會我們發現過去申請的空間太小了，有時候我們又會覺得申請的空間過大了，那為了合理的時候內存， 我們一定會對內存的大小做靈活的調整。那 realloc 函數就可以做到對動態開辟內存大小的調整。

//函數原型void *realloc(void *ptr, size_t size);//void *ptr   表示被調整的指針指向的地址//size_t size 表示改變之后的空間內存大小，單位是字節

• ptr 是要調整的內存地址
• size 調整之后新大小返回值為調整之后的內存起始位置
• 這個函數調整原內存空間大小的基礎上，還會將原來內存中的數據移動到新的空間
• realloc在調整內存空間的是存在兩種情況：?
• ???????????情況1： 原有空間之后有足夠大的空間
• ???????????情況2： 原有空間之后沒有足夠大的空間

圖解：?

??

例：?

#include #include #include int main(){	int *p =(int*)malloc(20);	if(p == NULL)	{		printf("%s/n", strerror(errno));	}	else	{		int i = 0;		for(i = 0; i < 10; i++)		{			printf("%d ", *(p + i));		}	}	//上方僅僅只是在使用malloc開辟的20個字節空間	//假設這里，20個字節空間不能滿足我們的需求了	//希望能夠有40個字節的空間	//這里就可以使用realloc來調整動態開辟的內存	int *ptr = realloc(p, INT_MAX);	if(ptr != NULL)	{		int i = 0;		for(i = 5; i < 10; i++)		{			*(p+i) = i;		}		for(i = 0; i < 10; i++)		{			printf("%d ", *(p + i));		}	}	//釋放動態開辟的內存空間	free(p);	p = NULL;	return 0;}

realloc 函數的注意事項：

1.如果 p 指向的空間有足夠的的內存空間可以追加，則直接追加，后返回 p

2.如果 p 指向的空間之后沒有足夠的內存空間可以追加，則 realloc 函數會重新找一個新的內存區域，開辟一塊滿足需求的空間，并且把原來內存中的數據拷貝回來，釋放舊的內存空間，最后返回新開辟的內存空間地址，而舊的那塊內存空間需要賦空指針，不然會形成野指針，造成非法訪問。

3.得用一個新的變量去接收 realloc 函數的返回值

注：以上四種函數頭文件均使用 stdlib.h 頭文件！

三、常見的動態內存錯誤

• 對NULL指針的解引用操作

#include #include int main(){	int *p = (int*)malloc(40);	//萬一malloc失敗了，p就會被賦值為NULL	//*p = 0;//error	int i = 0;	for(i = 0; i < 10; i++)	{		*(p+i) = i;//非法訪問	}	free(p);	p = NULL;	return 0;}

• 對動態開辟的空間越界訪問

#include #include int main(){	int *p = (int*)malloc(5 * sizeof(int));//只有5個元素	if( p == NULL)	{		return 0;	}	else	{		int i = 0;		for(i = 0; i < 10; i++)//只有5個元素，循環10次，會造成越界訪問		{			*(p+i) = i;		}	}	free(p);	p = NULL;	return 0;}

• 對非動態開辟內存使用 free 釋放

#include #include int main(){	int a = 10;	int *p = &a;	*p = 20;	free(p);	p = NULL;	return 0;}

• ---

  使用 free 釋放一塊動態開辟內存的一部分

#include #include int main(){	int *p = (int*)malloc(40);	if(p = NULL)	{		return 0;	}	int i = 0;	for(i = 0; i < 10; i++)	{		*p++ = i;	}	//此時p指向的不是動態開辟出的起始位置了		//回收空間，free只能釋放動態開辟出的起始位置	free(p);	p = NULL;	return 0;}

• ---

  對同一塊動態內存的多次釋放

#include #include int main(){	int *p = (int*)malloc(40);	if(p == NULL)	{		return 0;	}	//使用	free(p);	//p = NULL 需要定義為空指針才能引用下面的free	free(p);//重復釋放    return 0;}

• ---

  動態開辟內存忘記釋放（導致內存泄露）

#include #include int main(){	while(1)	{		malloc(1);//開辟完空間后一直沒有釋放	}	return 0;}

注：忘記釋放不再使用的動態開辟的空間會造成內存泄漏，動態開辟的空間一定要釋放，并且正確釋放

四、C/C++程序的內存開辟

C/C++程序內存分配的幾個區域：?

1. 棧區（stack）：在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集中，效率很高，但是分配的內存容量有限。 棧區主要存放運行函數而分配的局部變量、函數參數、返回數據、返回地址等。
2. 堆區（heap）：一般由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收 。分配方式類似于鏈表。
3. 數據段（靜態區）（static）：存放全局變量、靜態數據。程序結束后由系統釋放。
4. 代碼段：存放函數體（類成員函數和全局函數）的二進制代碼。

五、柔性數組

也許你從來沒有聽說過 柔性數組（flexible array）這個概念，但是它確實是存在的。 C99 中，結構中的最后一個元素允許是未知大小的數組，這就叫做?『柔性數組』成員。

例：

typedef struct S{	int n;	int arr[0];//未知大小的-柔性數組成員-數組的大小是可以調整的    //int arr[] 同上}S;

柔性數組的特點

• 結構中的柔性數組成員前面必須至少一個其他成員。
• sizeof 返回的這種結構大小不包括柔性數組的內存。
• 包含柔性數組成員的結構用 malloc () 函數進行內存的動態分配，并且分配的內存應該大于結構的大小，以適應柔性數組的預期大小。

例：?

#include typedef struct S{	int n;	int arr[0];//未知大小的-柔性數組成員-數組的大小是可以調整的}S;int main(){	struct S s;	printf("%d/n", sizeof(s));	return 0;}

執行結果：

柔性數組的使用

例：

#include #include typedef struct S{	int n;	int arr[0];//未知大小的-柔性數組成員-數組的大小是可以調整的}S;int main(){	struct S *ps = (struct S*)malloc(sizeof(struct S)+5*sizeof(int));	ps->n = 100;	int i = 0;	for(i = 0; i <5; i++)	{		ps->arr[i] = i;//0 1 2 3 4 	}	struct S *ptr = realloc(ps, 44);	if(ptr != NULL)	{		ps = ptr;	}	for(i = 5; i < 10; i++)	{		ps->arr[i] = i;	}	for(i = 0; i < 10; i++)	{		printf("%d ", ps->arr[i]);	}	free(ps);	ps = NULL;	return 0;}

執行結果 ：

圖解：

柔性數組的優勢

我們來看一下這段代碼比起上一段代碼的優勢?

優勢一：方面內存釋放

• 如果我們的代碼是在一個給別人用的函數中，你在里面做了二次內存分配，并把整個結構體返回給用戶。
• 用戶調用 free 可以釋放結構體，但是用戶并不知道這個結構體內的成員也需要 free ，所以你不能指望用戶來發現這個事。
• 所以，如果我們把結構體的內存以及其成員要的內存一次性分配好了，并返回給用戶一個結構體指針，用戶做一次 free 就可以把所有的內存也給釋放掉。

優勢二 : 這樣有利于訪問速度

• 連續的內存有益于提高訪問速度，也有益于減少內存碎片。（其實，我個人覺得也沒多高了，反正你跑不了要用做偏移量的加法來尋址）