為什么存在動態記憶體分配

我們已經掌握的記憶體開辟方式有：
例如

int val = 20;// 在堆疊空間上開辟四個位元組
char arr[10] = {0};// 在堆疊空間上開辟10個位元組的連續空間

但是上述的開辟空間的方式有兩個特點：
1.空間開辟大小是固定的，
2.陣列在申明的時候必須指定陣列的長度，它所需要的記憶體在編譯時分配，

但是對于空間的需求，不僅僅是上述的情況，有時候我們需要的空間大小在程式運行的時候才能知道，那陣列的編譯時開辟空間的方式就不能滿足了，
這時候就只能用動態記憶體開辟的方式了，
說明：
動態記憶體函式操作的記憶體都是在堆區上，

記憶體分配知識拓展

C/C++程式記憶體分配的幾個區域：

1.堆疊區(stack)：在執行函式時，函式內區域變數的存盤單元都可以在堆疊上創建，函式執行結束時這些存盤單元自動被釋放，堆疊記憶體分配運算內置于處理器的指令集中，效率很高，但是分配的記憶體容量有限， 堆疊區主要存放運行函式而分配的區域變數、函式引數、回傳資料、回傳地址等，

2. 堆區(heap)：一般由程式員分配釋放， 若程式員不釋放，程式結束時可能由OS回收 ，分配方式類似于鏈表，

3. 資料段(靜態區) (static)：存放全域變數、靜態資料，程式結束后由系統釋放，

4. 代碼段：存放函式體（類成員函式和全域函式）的二進制代碼，

動態記憶體函式

malloc和free函式

C語言提供了一個動態記憶體開辟的函式

根據函式的功能介紹，該函式會向記憶體申請一塊連續可用的空間，大小為 size（單位是位元組），并回傳指向這塊空間的指標，
注意：
1.如果開辟成功，則回傳一個指向開辟好空間的指標，
2.如果開辟失敗，則回傳一個NULL指標，因此malloc的回傳值一定要做檢查（即判斷是否為NULL），
3.回傳值的型別是 void* ，所以malloc函式并不知道開辟空間的型別，具體在使用的時候使用者自己來決定，
4.如果引數 size 為0，malloc的行為是標準是未定義的，取決于編譯器，

當空間被動態開辟后，程式運行結束，被用完的空間又會怎么處理呢？

C語言提供了另外一個函式free，專門是用來做動態記憶體的釋放和回收的，函式原型如下：

free函式用來釋放動態開辟的記憶體，
1.如果引數 ptr 指向的空間不是動態開辟的，那free函式的行為是未定義的，
2.如果引數 ptr 是NULL指標，則函式什么事都不做，
3.如果引數ptr指向的空間是動態開辟的，那free函式的行為就是釋放掉該動態開辟的空間，將其歸還給作業系統，但是對ptr沒有影響（為了防止對ptr的錯誤使用一般都會在free掉空間后再手動將ptr置位NULL），

注：malloc 和 free 都宣告在頭檔案 stdlib.h 中，
舉個栗子：

#include<stdlib.h>
#include<stdio.h>
int main()
{
    //開辟空間
	int* ptr = (int*)malloc(10 * sizeof(int));//開辟10個整型大小的空間，且將ptr強制型別轉換int*型 指向這塊空間
	if (ptr == NULL)
	{
		perror("main");//當ptr為NULL時，列印出錯誤資訊
		return 0;
	}
	//使用空間
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(ptr + i) = i;
		printf("%d ", *(ptr + i));
	}
	//回收空間
	free(ptr); //將ptr指向的空間釋放，還給系統
	ptr = NULL; //手動將ptr置為NULL
	return 0;
}

結果：

從以上結果可見malloc函式開辟空間成功，

calloc函式

C語言還提供了一個函式叫 calloc ， calloc 函式也用來動態記憶體分配，原型如下：

1.函式的功能是為 num 個大小為 size（單位位元組） 的元素開辟一塊空間，并且把空間的每個位元組初始化為0，
2.與函式 malloc 的區別只在于 calloc 會在回傳地址之前把申請的空間的每個位元組初始化為全0，
3.如果函式開辟記憶體成功，則回傳一個指向開辟好空間的指標，如果開辟失敗，則回傳一個NULL指標，
舉個栗子：

所以如果我們對申請的記憶體空間的內容要求初始化，那么可以很方便的使用calloc函式來完成任務，

realloc函式

realloc函式的出現讓動態記憶體管理更加靈活，
有時會我們發現過去申請的空間太小了，有時候我們又會覺得申請的空間過大了，那為了合理的時候記憶體，我們一定會對記憶體的大小做靈活的調整，那 realloc 函式就可以做到對動態開辟記憶體大小的調整，
函式原型如下：

ptr是要調整的記憶體地址,size調整之后新大小,回傳值為調整之后的記憶體起始位置，該函式也如前兩個函式，如果函式開辟記憶體成功，則回傳一個指向開辟好空間的指標（即調整之后的記憶體起始位置），如果調整空間失敗，則回傳一個 NULL 指標，

realloc函式在調整原記憶體空間大小的基礎上,還會將原來記憶體中的資料移動到新的空間；具體調整記憶體空間時存在兩種情況：
情況1：原有空間之后有足夠大的空間，如圖

當為這種情況時，要擴展記憶體就直接原有記憶體之后直接追加空間，原來空間的資料不發生變化，

情況2：原有空間之后沒有足夠大的空間，如圖

當是這種情況時，原有空間之后沒有足夠多的空間時，擴展的方法是：在堆空間上另找一個合適大小的連續空間來使用，這樣函式回傳的是一個新的記憶體地址，

舉個栗子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));//開辟10位元組的空間大小
	if (p == NULL)
	{
		printf("記憶體開辟失敗\n");
	}
	else
	{
		//使用開辟的空間，當空間不能滿足使用時，需擴展空間
		//擴展空間
		int* ptr = (int*)realloc(p, 30);//定義1個新的指標，將空間擴展為30個位元組大小
		if (ptr != NULL)
		{
			p = ptr;//當函式調整空間成功時，再將新指標賦給原來的指標p
		            //注意:若這里不進行判斷ptr是否為空指標，則當出現開辟空間失敗的情況時，ptr就會
		            //為NULL,再將ptr賦給p,則原先開辟的空間也會被置為NULL,就會造成得不償失的情況
			//使用
			//......
		}
		//使用結束，釋放記憶體
		free(p);
		p = NULL;
	}
	return 0;
}

小提示：在使用malloc、calloc、realloc 這三個函式時，記住使用完成之后，都要用free函式來釋放記憶體，并將函式對應的起始地址置為空指標 !

常見的動態記憶體錯誤

1. 對NULL指標的解參考操作

例如：

void test()
{
   int *p = (int *)malloc(INT_MAX);
   *p = 20;//如果p的值是NULL，就會有問題
   free(p);
}	

即當函式開辟空間失敗時，函式就會回傳NULL，而此時再對該函式的回傳值解參考，就會出錯，如上代碼，

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

void test()
{
    int i = 0;
    int *p = (int *)malloc(10*sizeof(int));
    if(NULL == p)
{
    printf("記憶體開辟失敗\n");
}
for(i=0; i<=10; i++)
{
    *(p+i) = i; //當i是10的時候越界訪問
}
free(p);
}

若動態開辟的空間越界訪問則會出現的結果：

3. 對非動態開辟記憶體使用free釋放

例如如下情形

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

該情況會引發例外

4. 使用free釋放一塊動態開辟記憶體的一部分

void test()
{
   int *p = (int *)malloc(100);
   p++;
   free(p); //此時的p不再指向動態記憶體的起始位置
}

此種情況也會引發例外

5. 對同一塊動態記憶體多次釋放

void test()
{
   int *p = (int *)malloc(100);
   free(p);
   //使用
   //......
   free(p);//重復釋放
}

會引發例外

6. 動態開辟記憶體忘記釋放（記憶體泄漏）

void test()
{
   int *p = (int *)malloc(100);
   if(NULL != p)
   {
      *p = 20;
   }
}
//函式運行結束時，指向動態開辟空間的指標 p 會消失，而 p 指向的
//記憶體空間不會消失，但是該空間又沒被回收，所以會造成程式的泄露
int main()
{
   test();
   return 0;
}

當開辟的動態記憶體使用完成后沒有free釋放，這種情形會造成記憶體泄露，
所以切記： 動態開辟的空間一定要釋放，并且要正確釋放，

注：
動態開辟的空間有兩種回收方式：
1.主動使用free函式釋放，還給系統
2.整個程式結束時會釋放

經典筆試題

題目1

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

請問運行Test函式會有什么樣的結果？
該程式不會輸出任何結果，并造成空間泄露，

原因：指標 str 傳給 GetMemory 函式時為值傳遞，所以 GetMemory 函式的形參 p 是 str 的一份臨時拷貝，在 GetMemory 函式記憶體申請動態開辟的空間的地址存放在 p 中，不會對該函式外的 str 造成影響，所以，當 GetMemory 函式運行完回傳之后，str 依舊是 NULL .所以 strcpy 會失敗，除此之外，當 GetMemory 函式回傳后，指標 p 會銷毀，使得動態開辟的100個位元組的空間泄露，無法釋放，

如何修改：

char* GetMemory(char* p) //函式的回傳值為char*型
{
	p = (char*)malloc(100);//在堆上開辟的空間，該空間出了函式不會被銷毀
	return p;//回傳開辟動態記憶體的起始地址
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory(str); //str接識訓傳的動態記憶體的地址
	strcpy(str, "hello world");
	printf(str);//列印出內容
	free(str);//釋放空間
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

題目2

char* GetMemory(void)
{
char p[] = "hello world";//在堆疊上開辟的空間，出了函式會被銷毀
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}

請問運行Test函式會有什么樣的結果？
該程式不會輸出任何結果，
原因：在 GetMemory 函式內部，當創建陣列 p 后（在堆疊上開辟的空間，出了該函式的范圍就會被銷毀），函式結束回傳陣列名p(即首元素的地址)后，此時的陣列內容（即字串）也會被銷毀，雖然在 Test 函式內部有 str 接收該地址，但地址 p 指向的字串已經被銷毀，所以最終結果為不會輸入任何內容，

題目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);
}

請問運行Test 函式會有什么樣的結果？
GetMemory 函式中動態開辟的記憶體在 Test 函式中使用完后沒用free函式釋放，會造成空間泄露，

題目4

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

請問運行Test 函式會有什么樣的結果？
在使用 strcpy 函式前指標 str 指向的空間已經被釋放掉了，此時的 str 不再指向被動態開辟的空間，所以不會發生字串的拷貝，