1.為什么要有動態內存分配

我們已經掌握的內存開辟方式有：

int val = 20;//在棧空間上開辟四個字節
char arr[10] = { 0 };//在棧空間上開辟10個字節的連續空間

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

• 空間開辟大小是固定的
• 數組在申明的時候，必須指定數組的長度，數組空間一旦確定了大小，就不能調整了

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

C語言引入了動態內存開辟，讓程序員自己可以申請和釋放空間，就比較靈活了。

2.malloc和free

2.1malloc

C語言提供了一個動態內存開辟的函數：

void* malloc(size_t size);

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

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

2.2free

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

void free(void* ptr);

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

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

malloc和free都聲明在stdlib.h 頭文件中。

舉個例子：

#include <stdio.h>
#include <stdlib.h>int main()
{int num = 10;int arr[10] = { 0 };int* ptr = NULL;//申請空間ptr = (int*)malloc(num * sizeof(int));if (ptr != NULL){int i = 0;for (i = 0; i < num; i++){*(ptr + i) = 0;}for (i = 0; i < num; i++){printf("%d ", * (ptr + i));}}//釋放空間free(ptr);ptr = NULL;//是否有必要？return 0;
}

3.calloc和realloc

3.1calloc

C語言還提供一個叫 calloc，calloc函數也用來動態內存分配。原型如下：

void* calloc(size_t num, size_t size);

輸出結果：

0 0 0 0 0 0 0 0 0 0

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

3.2realloc

• realloc函數的出現讓動態內存管理更加靈活。

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

函數原型如下：

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

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

• 情況1;
  當是情況1的時候，要擴展內存就直接原有內存之后直接追加空間，原來空間的數據不發生變化。

• 情況2：
  當是情況2 的時候，原有空間之后沒有足夠多的空間時，擴展的方法是：在堆空間上另找一個合適的連續空間來使用。這樣函數返回的是一個新的內存地址。

由于上述的兩種情況，realloc 函數的使用就要注意一下了。

#include <stdio.h>
#include <stdlib.h>int main()
{int* ptr = (int*)malloc(sizeof(int));if (ptr != NULL){//業務處理}else{return 1;}//擴展容量//代碼1 - 直接將realloc的返回值放到ptr中//ptr = realloc(ptr, 1000);//這樣可以嗎？（如果申請失敗的話，會怎樣？）//代碼2 - 先將realloc函數的返回值放到p中，不為NULL，再放到ptr中int* p = (int*)realloc(ptr, 1000);if (p != NULL){ptr = p;}//業務處理//釋放空間free(ptr);return 0;
}

4.常見的動態內存管理的錯誤

4.1對NULL指針解引用操作

#include <stdio.h>
#include <stdlib.h>
void test()
{int* p = (int*)malloc(INT_MAX / 4);*p = 20;//假如p的值為NULL，就會有問題free(p);
}

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

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

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

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

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

void test()
{int* p = (int*)malloc(100);p++;free(p);//不在指向動態內存的起始位置
}

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

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

4.6動態開辟內存忘記釋放（內存泄漏）

#include <stdio.h>
#include <stdlib.h>void test()
{int* p = (int*)malloc(100);if (p != NULL){*p = 20;}
}int main()
{//test();test();while (1);//死循環了return 0;
}

5.動態內存管理經典筆試題分析

5.1 題目1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>void GetMemory(char* p)
{p = (char*)malloc(100);
}void Test(void)
{char* str = NULL;GetMemory(str);strcpy(str, "hello world");printf(str);
}int main()
{Test();return 0;
}

請問運行test 函數會有什么樣的結果？

原因：對NULL解引用操作 - 程序奔潰

改正：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>void GetMemory(char** p)
{*p = (char*)malloc(100);
}void Test(void)
{char* str = NULL;GetMemory(&str);strcpy(str, "hello world");printf(str);free(str);str = NULL;
}int main()
{Test();return 0;
}

5.2 題目2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>char* GetMemory(void)
{char* p = "hello world";return p;
}void Test(void)
{char* str = NULL;str = GetMemory();printf(str);
}int main()
{Test();return 0;
}

請問運行test 函數會有什么樣的結果？

原因：等GetMemory函數返回后，使用str指針去訪問p數組，就是非法訪問，因為p數組的內存已經還給操作系統了。str變成了野指針（返回棧空間地址的問題）。

5.3 題目3

#include <stdio.h>
#include <stdlib.h>
#include <string.h>void* GetMemory(char* p, int num)
{*p = (char*)malloc(num);
}void Test(void)
{char* str = NULL;GetMemory(str, 100);strcpy(&str, "hello world");printf(str);
}int main()
{Test();return 0;
}

請問運行test 函數會有什么樣的結果?

5.4 題目4

#include <stdio.h>
#include <stdlib.h>
#include <string.h>void Test(void)
{char* str = (char*)malloc(100);strcpy(str, "hello");free(str);if (str != NULL){strcpy(str, "world");printf(str);}
}
int main()
{Test();return 0;
}

請問運行Test會有什么樣的結果？

原因：因為在free掉str的內存空間時，再去訪問它就變成了非法訪問內存的空間

6.柔性數組

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

//例如：
struct st_type
{int i;int arr[0];//柔性數組成員
};//有些編譯器會報錯，無法編譯 可以改成：
struct st_type
{int i;int arr[];//柔性數組成員
};

6.1柔性數組的特點

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

//例如：
#include <stdio.h>typedef struct st_type
{int i;int arr[0];//柔性數組成員
}st_type;int main()
{printf("%zd\n", sizeof(st_type));//4return 0;
}

6.2柔性數組的使用

//代碼1：
#include <stdio.h>
#include <stdlib.h>typedef struct st_type
{int i;int arr[0];//柔性數組成員
}st_type;int main()
{int i = 0;st_type* p = (st_type*)malloc(sizeof(st_type) + 100 * sizeof(int));//業務處理：p->i = 100;for (i = 0; i < 100; i++){p->arr[i] = i;}//釋放空間free(p);p = NULL;return 0;
}

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

6.3柔性數組的優點

上述的st_type結構也可以設計為下面的結構，也能完成同樣的效果。

//代碼2
#include <stdio.h>
#include <stdlib.h>typedef struct st_type
{int i;int* p_a;//柔性數組成員
}st_type;int main()
{int i = 0;st_type* p = (st_type*)malloc(sizeof(st_type));p->i = 100;p->p_a = (st_type*)malloc(p->i * sizeof(st_type));//業務處理：for (i = 0; i < 100; i++){p->p_a[i] = i;}//釋放空間free(p->p_a);p->p_a = NULL;free(p);p = NULL;return 0;
}

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

第一個好處是：方便內存釋放：

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

第二個好處是：這樣有利于訪問速度

連續的內存有益于提高訪問速度，也有益于減少內存碎片。

7.總結C/C++中程序內存區域劃分

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

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