什么是動態(tài)內存分配

我們都知道在C語言中，定義變量的時候，系統(tǒng)就會為這個變量分配內存空間，而且這個空間是在棧上開辟的，這種方式就會有兩個特點。

• 開辟的空間大小是固定的
• 數組在申明的時候，必須要指定數組的長度，以方便為其分配內存大小

但是這種方法并不能滿足我們在開發(fā)中的需要，因為有時候我們需要開辟的空間大小，是在程序巡行的過程中才能知道要開辟多大的。

這時候，數組的這種開辟方式就不能滿足了，因此也就有了動態(tài)內存分配的需要。

而動態(tài)內存分配，會根據需求而分配空間，大小是可以變化的，并且是在堆區(qū)上分配空間，而堆區(qū)的內存空間大小一半都會比棧區(qū)大。

動態(tài)內存函數的介紹

需要需要動態(tài)內存管理，需要了解C語言中一下的幾個函數。

統(tǒng)一說明：一下的函數都包含在<stdlib.h>中。

free

void free (void* ptr)；

為了后面可以進行代碼演示，這里先介紹free這個函數。

我們在使用相關函數動態(tài)開辟了內存空間之后，函數會返回這片空間的的首地址給使用者，當使用者用完空間之后，需要手動對這片空間進行釋放，把內存空間還給操作系統(tǒng)。

如果參數 ptr 指向的空間不是動態(tài)開辟的，那free函數的行為是未定義的。
如果參數 ptr 是NULL指針，則函數什么事都不做。
釋放的空間是ptr所指向的那塊內存空間

上面的第一種情況，有可能編譯器會報錯。

如果我們僅僅只是開辟空間使用，而不釋放的話，會占用內存空間資源，造成內存泄漏，影響性能。

因此，我們需要養(yǎng)成用完就釋放的好習慣。

malloc

void* malloc (size_t size);

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

連續(xù)可用的特點，就像數組一樣。

如果開辟成功，則返回一個指向開辟好空間的指針。
如果開辟失敗，則返回一個NULL指針。
返回值的類型是 void* ，因此使用者需要根據自己的需求來轉化使用。
如果參數size大小為0，malloc 的行為是標志沒有規(guī)定的，取決于編譯器。

size的大小是按照字節(jié)為單位的。

#include <stdio.h>

int main()
{
	//代碼1
	int num = 0;
	scanf("%d", &num);
	int arr[num] = { 0 };

	//代碼2
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)//判斷ptr指針是否為空
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}

	free(ptr);//釋放ptr所指向的動態(tài)內存
	ptr = NULL;//是否有必要？
	return 0;
}

上面的代碼就是malloc函數的基本使用過程，在代碼1中，這樣的使用方法，一般來說編譯器是不支持的，而第二種方法，也就是動態(tài)內存開辟的方法，編譯器就支持。

在最后，記得要把ptr所指向的空間給釋放掉。

這個時候，ptr種存儲的仍然是那塊空間的地址，這就稱為了野指針，所以我們還要把ptr置空。

calloc

與malloc類相似的，C語言還提供了另外一個動態(tài)開辟內存的函數，那就是calloc。

void* calloc (size_t num, size_t size);

需要注意的是，這個函數的參數有所不同，第一個參數num是用來確定你開辟的連續(xù)空間是用來存放多少個元素的，而第二個參數size表示的是一個元素占用多少的字節(jié)。

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

所以，如果我們需要在動態(tài)開辟內存的時候進行初始化，我們可以使用calloc這個函數。

我們可以通過調試的監(jiān)視窗口來查看這個函數在開辟空間的時候是否幫我們初始化。

#include <stdlib.h>


int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		//使用空間
	}
	free(p);
	p = NULL;
	return 0;
}

realloc

有時候我們會發(fā)現，哪怕是使用上面的動態(tài)內存管理的函數，也會有不方便的時候。我們可能會因為空間申請小了不夠用而去擴容，但是如果我們使用上面兩個函數去開辟更大的空間的時候，之前的數據拷貝過來新開辟的更大的空間又很麻煩。

這個時候，我們就可以使用realloc了。

void* realloc (void* ptr, size_t size);

ptr 是要調整的內存地址。
size 調整之后新大小，和malloc一樣，是以字節(jié)為單位的。
返回值為調整之后的內存起始位置。
這個函數調整原內存空間大小的基礎上，還會將原來內存中的數據移動到新的空間。

在realloc函數使用的時候，會出現兩種情況：

原有的空間之后還有足夠的空間

如果原來的內存空間之后還有足夠的空間來滿足新的大小，這時候就會直接對原來的空間進行擴容，原來空間的數據不會發(fā)生變化。

原有的空間之后沒有足夠的空間

如果原來的空間之后沒有足夠的空間滿足需要，就會在內存區(qū)域中開辟一片能夠滿足新的大小需要的連續(xù)空間，并且把原來空間的數據拷貝的新的空間中，釋放原來的空間，返回新的地址。

#include <stdio.h>

int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//業(yè)務處理
	}
	else
	{
		exit(EXIT_FAILURE);
	}

	//擴展容量

	//代碼1
	ptr = (int*)realloc(ptr, 1000);
	
	//代碼2
	int* p = NULL;
	p = realloc(ptr, 1000);
	if (p != NULL)
	{
		ptr = p;
	}
	//業(yè)務處理
	free(ptr);
	return 0;
}

上述代碼種，代碼1的做法是不安全的，如果我們擴容失敗后，會返回空指針，這個時候，ptr接收了空指針，就會造成ptr原來的那塊空間的數據丟失，并且造成內存泄漏。

因此，一般我們都需要像代碼2那樣，先用一個臨時的指針變量接收返回值，并且在判定不為空指針后再復制給ptr。

動態(tài)內存管理中常見的錯誤

我們在使上面這些函數的時候，會經常出現一下的錯誤。

對NULL指針的解引用操作

void test()
{
	int* p = (int*)malloc(INT_MAX / 4);

	//沒有進行判空，就直接使用空間
	*p = 20;//如果p的值是NULL，就會有問題
	free(p);
}

對動態(tài)開辟空間的越界訪問

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//當i是10的時候越界訪問
	}
	free(p);
}

對非動態(tài)開辟內存使用free釋放

void test()
{
int a = 10;
int *p = &a;
free(p);
}

使用free釋放一塊動態(tài)開辟內存的一部分

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//p不再指向動態(tài)內存的起始位置
	//這樣做一般編譯器也會報錯的
}

對同一塊動態(tài)內存多次釋放

void test()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重復釋放，一般來說，編譯器會報錯
}

動態(tài)開辟內存忘記釋放（內存泄漏）

void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}
int main()
{
	test();
	while (1);
}

我們在使用上面的函數的時候，一定要小心，避免上面的這些錯誤。

一些經典的筆試題

題目1

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}

上面的代碼有錯，在開辟空間后，沒有進行判空操作，并且在調用GetMemory函數的時候，傳入的形參是str的一份臨時拷貝，在函數內部p的改變不會改變main中的str，所以在GetMemory返回的時候，p所指向的空間會泄漏，并且在strcpy中，造成了對空指針的解引用操作。

題目2

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

這段代碼也是錯誤的，在GetMemory中，不是用動態(tài)內存管理的函數來開辟空間，而是使用數組的開辟方式，這樣的開辟方式會在棧區(qū)開辟空間，當GetMemory函數調用完成的時候，就會銷毀開辟的數組，這時候，外面的str接收了返回的數組的地址，就會變成一個野指針。

題目3

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}

上面的代碼在使用完成動態(tài)開辟的空間后沒有進行判空操作，并且沒有進行內存釋放，造成了內存泄漏。

題目4

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

上面的代碼提前釋放了空間，后面又使用指針對已經釋放的空間進行操作，這是非法的，釋放后，指向這塊空間的指針就是野指針，需要進行置空。

柔性數組

C99 中，結構中的最后一個元素允許是未知大小的數組，這就叫做『柔性數組』成員。

例如：

typedef struct st_type
{
	int i;
	int a[0];//柔性數組成員
}type_a;

如果有的編譯器報錯，可以改成下面這個樣子

typedef struct st_type
{
	int i;
	int a[];//柔性數組成員
}type_a;

柔性數組的特點

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

例如：

//code1
typedef struct st_type
{
	int i;
	int a[0];//柔性數組成員
}type_a;
printf("%d\n", sizeof(type_a));//輸出的是4

typedef struct st_type
{
	int i;
	int a[0];//柔性數組成員
}type_a;

//代碼1
int i = 0;
type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
//業(yè)務處理
p->i = 100;
for (i = 0; i < 100; i++)
{
	p->a[i] = i;
}
free(p);

這樣柔性數組成員a，相當于獲得了100個整型元素的連續(xù)空間。

柔性數組的優(yōu)勢

上面的代碼也可以這樣設計：

//代碼2
typedef struct st_type
{
	int i; 
	int* p_a;
}type_a;

type_a* p = (type_a*)malloc(sizeof(type_a));
p->i = 100;

p->p_a = (int*)malloc(p->i * sizeof(int));

//業(yè)務處理
for (i = 0; i < 100; i++)
{
	p->p_a[i] = i;
}

//釋放空間
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;

上述 代碼1 和 代碼2 可以完成同樣的功能，但是 方法1 的實現有兩個好處：

• 方便內存釋放
• 這樣有利于訪問速度

到此這篇關于C語言動態(tài)內存管理分析總結的文章就介紹到這了,更多相關C語言 動態(tài)內存管理內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論