1.动态内存开辟的原因

常见的内存开辟方式

int val = 20;//在栈空间上开辟四个字节的空间

char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

上面开辟空间的方式有两个特点：

1.空间开辟的大小是固定的；

2. 数组在声明的时候，必须指定数组的长度，它所需要的空间在编译时分配；

但是对于空间的需求，不只是上面的情况，有时候需要的空间大小在程序运行的时候才能得知，这时候数组的编译时开辟空间的方式就不能满足了。

所以需要动态开辟内存

2.动态内存函数的介绍

动态内存的开辟都是在内存的堆区中进行开辟的

2.1malloc和free

C语言提供了一个动态开辟内存的函数：

void* malloc(size_t size);

malloc函数向内存申请一块连续可用的空间，并返回指向这块空间起始位置的指针。

1.如果开辟成功，则返回一个指向开辟好的空间的指针；

2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查，不然可能会造成野指针的问题；

3.返回值的类型时void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者自己来决定返回值的类型；

4.如果参数size为0，此时malloc函数的行为是标准未定义的，取决于程序运行时使用的编译器；

malloc的使用：

vint main(){int* p = (int*)malloc(40);//向内存申请一块40字节的空间，并对放回的指针类型转换if (p == NULL)//返回NULL指针时让打印错误信息并让程序结束{perror("malloc");return 1;}int i = 0;for (i = 0; i < 10; i++){*(p + i) = i;}return 0;}

要记得包含头文件

这样就对开辟的内存空间进行了一个使用了，但是还有点问题，因为向内存申请的空间没有进行释放。

所以这时就引入了另一个函数free

C语言提供了另一个函数free，专门用来做动态内存的释放和回收的

void free(void* ptr);

free函数用来释放动态开辟的内存

1.如果参数ptr指向的空间是不是动态开辟的，那么free函数的行为是未定义的；

2.如果参数 ptr是NULL指针，则free函数什么事也不做；

malloc和free函数都声明在stdlib.h头文件中

free的使用：

int main(){int* p = (int*)malloc(40);//向内存申请一块40字节的空间，并对放回的指针类型转换if (p == NULL)//返回NULL指针时让打印错误信息并让程序结束{perror("malloc");return 1;}int i = 0;for (i = 0; i < 10; i++){*(p + i) = i;}free(p);//释放p所指向的动态内存p == NULL;//将p的值置为NULLreturn 0;}

free的参数一定是动态开辟内存空间的那个起始位置的地址，否则会报错

在用free释放完动态开辟的内存之后，要对之前指向动态开辟空间的那个指针置为NULL，因为那块动态开辟的空间已经被操作系统回收了，没有了访问的权限，所以要让p的值为NULL，避免野指针的问题。

如果对动态内存开辟的空间没有释放掉，会出现一个内存泄漏的问题。

2.2calloc

C语言还提供了一个calloc函数，calloc也是用来进行动态内存的分配

void* calloc(size_t num, size_t size);

 1.calloc的功能是为num个字节大小为size的元素开辟一个空间，并且把空间的每个字节的数据都初始化为0，然后返回这块连续空间的起始位置的地址；

2.与malloc函数的区别只在于，calloc在返回地址之前会把申请的空间的每个字节的数据都初始化为全0；

calloc的使用：

int main(){int* p = (int*)calloc(10, 4);if (p == NULL){perror("calloc");return 1;}free(p);p = NULL;return 0;}

内存情况：

 可以看到，动态开辟的40个字节的空间都被初始化为全0

所以如果要对动态开辟的空间进行初始化，可以直接使用calloc函数来完成

2.3realloc

有时会发现申请的空间太大或者太小了，为了合理的使用内存，一定会对内存的大小做一个灵活的调整，那么realloc函数就可以做到对动态开辟内存大小的调整

realloc函数的出现让动态内存管理更加灵活

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

1.ptr是要调整的内存空间；

2.size是调整之后的新大小；

3.返回值为调整之后的内存起始位置；

4.realloc函数在调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间；

realloc函数在调整内存空间时存在两种情况：

情况1：要调整的空间之后有足够的空间来存放调整之后的大小

情况2：要调整的空间之后没有足够大的空间

如果是情况1，那么就在原有的内存之后追加新的空间，原来空间的数据不发生变化。

如果是情况2，原有空间之后没有足够多的空间，此时就会在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址 

 并且realloc函数还会将原空间的数据移动到新的空间。

如果realloc函数在堆区中都找不到一块合适的空间，则会返回NULL指针。        

realloc的使用：

int main(){int* p = (int*)calloc(10, 4);if (p == NULL){perror("calloc");return 1;}p = realloc(p, 1000);if (p == NULL){perror("realloc");return 1;}free(p);p = NULL;return 0;}

其次，realloc函数还能使原有空间变小：

使用：

int main(){int* p = (int*)calloc(10, 4);if (p == NULL){perror("calloc");return 1;}p = realloc(p, 20);if (p == NULL){perror("realloc");return 1;}free(p);p = NULL;return 0;}

内存情况：

补充：realloc的地址参数是NULL时,realloc(NULL, 40);和malloc(40);的意思是一样的。 

3.常见的动态内存错误

3.1对NULL指针的解引用操作

 这里编译器直接把对NULL指针的解引用操作给取消掉了，如果在其他的编译器下运行，可能会出现问题，所以一定要对动态开辟内存函数的返回值进行一个NULL指针的判断。

3.2对动态开辟空间的越界访问

int main(){int* p = (int*)malloc(40);if (p == NULL){perror("malloc");return 1;}int i = 0;for (i = 0; i <= 10; i++){*(p + i) = i;}free(p);p = NULL;return 0;}

其中*(p + 10) = 10;时对动态开辟的空间进行了一个越界访问了，编译器直接报错

3.3对非动态开辟内存使用free

对栈区上的空间使用free：

int main(){int a = 0;free(&a);return 0;}

此时编译器也会给出一个错误 

3.4使用释放一块动态开辟内存的一部分

int main(){int* p = (int*)malloc(40);p++;free(p);return 0;}

此时p没有指向动态开辟内存的起始位置

编译器同样给出了一个错误

3.5对同一块动态内存多次释放

int main(){int* p = (int*)malloc(40);free(p);free(p);return 0;}

 p已经释放过了

3.6动态开辟内存忘记释放（内存泄漏）

在向内存申请了一块空间之后没有对其进行释放会造成内存泄漏的问题

会迅速吃满你的内存

int main(){while (1){malloc(40);}return 0;}

 如图：

如果程序在没有结束之前申请的内存都没有进行释放的话，就会出现内存泄漏的问题。所以在申请好一块内存之后要记得对其进行释放。

总结：

忘记释放不再使用的动态内存开辟的空间就会造成内存泄漏的问题，而且动态开辟的空间要正确释放。

4.练习

4.1练习1

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

请问运行Test 函数会有什么样的结果？

先创建了一个字符指针变量赋值为NULL，然后调用函数GerMemory，调用函数时形参只是一份对实参的临时拷贝，函数调用时，申请了一块动态开辟内存，但是并没有返回p，p在函数调用结束后销毁了，所以此时str指向的还是NULL，strcpy使用时对NULL指针进行了解引用，造成了非法访问，野指针的问题，也造成了动态内存错误

4.1练习2

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

请问运行Test 函数会有什么样的结果？

调用GetMemory函数时在栈区开辟了一块数组的空间，而在函数调用结束后数组开辟的空间已经被回收了，str接收了p的值，而p所指向的空间已经被回收了，所以p所指向的值也会发生变化，所以此时printf(str);打印的会是未知的结果

4.3练习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函数时传址调用，将申请的动态开辟内存空间的起始位置地址给了str，所以能够正常访问开辟的内存。不过没有进行free会造成内存泄漏的问题。

4.4练习4

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

请问运行Test 函数会有什么样的结果？

此时已经str所指向的动态内存空间已经释放掉了，会造成非法访问。

5.C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1.栈区：在执行函数时，函数内部变量的存储单元都可以在栈上创建，函数结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而存放的局部变量、函数参数、返回数据、返回地址等。

2.堆区：一般有程序员分配，若程序员不释放，程序结束时可能由OS回收，分配方式类似于链表。

3.数据段（静态区）：存放全局变量，静态数据，程序结束后由系统释放。

4.代码段：存放函数体的二进制代码

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁，但是被static修饰的变量存放在数据段，数据段的特点是，在上面创建的变量，直到程序结束才销毁，所以static修饰的变量生命周期变长了。

6.柔性数组

在C99中引入了一个叫做柔性数组的概念，在声明结构体类型时，结构中的最后一个元素允许是未知大小的数组，就是[]里面不放数字，或者在[]里面放一个0，这个数组就叫做柔性数组成员

这么声明：

struct S1{int num;int arr1[];//柔性数组成员};

或者：

struct S2{int num;int arr2[0];//柔性数组成员};

第2种写法在部分编译器可能会报错，这时候改成第1种就好了，意思是一样的。

6.1柔性数组成员的特点

1.结构中的柔性数组成员前面必须至少有1个其他的成员；

2.用sizeof去计算这种有柔性数组成员的结构大小中不包含柔性数组的内存；

3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小；

特点2的代码如下： 

struct S2{int num;int arr2[0];//柔性数组成员};int main(){printf("%d\n", sizeof(struct S2));return 0;}

程序运行结果是4

6.2柔性数组的使用：

struct S1{int num;int arr1[];//柔性数组成员};int main(){struct S1* pc = (struct S1*)malloc(sizeof(struct S1) + 10 * sizeof(int));//给柔性数组分配了10个整型元素的连续空间if (pc == NULL){return 1;}int i = 0;for (i = 0; i arr1[i] = i;printf("%d ", pc->arr1[i]);}free(pc);pc = NULL;return 0;}

将开辟的空间的起始位置地址用结构体指针来接收，之后再对这个结构体指针来解引用的时候，这样开辟的空间就相当于是一个结构体了。

6.3柔性数组的优势

如下代码是一种类型于柔性数组的效果：

struct S1{int num;int* arr1;};int main(){struct S1* ps = (struct S1*)malloc(sizeof(struct S1));//给结构体开辟了一块动态内存if (ps == NULL){return 1;}ps->arr1 = (int*)malloc(10 * sizeof(int));//另外开辟了一块动态内存并让结构体中的int*成员指向这块内存if (ps->arr1 == NULL){return 1;}int i = 0;for (i = 0; i arr1[i] = i;printf("%d ", ps->arr1[i]);}free(ps->arr1);//先释放掉后结构体中指针成员指向的那块空间，防止内存泄漏ps->arr1 = NULL;free(ps);ps = NULL;return 0;}

画个图来理解：

方法1：柔性数组的内存开辟：

方法2：结构体中的成员指针指向的新开辟的空间：

 方法1中内存只开辟了一次，而方法2中内存开辟了两次，第2次开辟的空间的地址给了第1次开辟的空间中的指针成员。

 两者都可以实现同样的功能，但是方法1也就是柔性数组的实现有两个好处：

1.方便内存的释放

如果写的代码是在一个给别人用到函数中，你在里面做了两次的内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也要进行free，所以要把结构体的内存以及其成员的内存一次性分配好，并返回用户一个结构体指针，这样用户只需要free一次就可以把结构体指针指向的内存释放掉了。

2.有利于访问的速度

连续的内存有利于提高访问速度，也有益于减少内存碎片（内存碎片就是已开辟的连续内存之间的内存）

关于动态内存管理的内容就讲到这里了，今后也会不定期更新