C进阶---动态内存管理

一、为什么存在动态内存分配

1.1静动态内存分配区别：

1.2静态分配的优缺点

1.3动态分配优缺点

二、动态内存函数的介绍

2.1malloc和free

2.2calloc

2.3realloc

三、常见的动态内存错误

3.1对NULL指针的解引用操作

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

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

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

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

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

四、C/C++程序的内存开辟

五、柔性数组

5.1柔性数组概念

5.2柔性数组的特点

5.3柔性数组的使用

5.4柔性数组的优势

当我们使用一个空间时，如果还是固定的开辟一定的空间，当使用过小时会浪费很多，当使用过多又要重新开辟空间，动态内存就是可以让我们灵活的使用空间，既不浪费，又能灵活的增加。

今天，我们就来详细学习动态内存管理。

一、为什么存在动态内存分配

我们已经知晓的的内存开辟方式：

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

这都是在栈上开辟空间

栈上开辟空间的方式存在两个特点：

1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

为什么要使用动态分配的原因

当我们事先不知道程序需要多少内存的时；
当我们希望数据结构没有固定的内存空间上限时；
当你想更有效地使用你的内存空间时。例如：如果你为一个一维数组分配的内存空间是 array[20]，而你最终只使用了 10 个内存空间，那么剩下的 10 个内存空间就被浪费了，这些浪费的内存甚至不能被其他程序变量所使用；
动态创建的列表的插入和删除可以非常容易地通过操作地址来完成，而在静态分配的内存中，插入和删除会导致更多的移动和内存浪费；
当你想在编程中使用结构和链表的概念时，动态内存分配是必须的。

1.1静动态内存分配区别：

序号	静态内存分配	动态内存分配
1	在静态内存分配中，变量被永久地分配内存，直到程序执行结束/函数调用结束	在动态内存分配中，只有当你的程序单元被激活时才会为变量分配内存
2	静态内存分配在程序执行前完成	动态内存分配在程序执行过程中完成
3	使用栈来管理静态分配的内存	使用堆来管理动态分配的内存
4	较不高效 (less efficient)	较高效
5	在静态内存分配中，不存在内存的重用	在动态内存分配中，存在内存的重用，而且在不需要时可以内存可以被释放
6	在静态内存分配中，一旦内存被分配，内存大小就不能再改变	在动态内存分配中，分配了内存后，内存的大小可以改变
7	在静态内存分配方案中，我们不能重新使用未使用的内存	动态内存分配中，允许重复使用内存。用户可以在需要时分配更多的内存。同时，用户也可以在需要时释放内存。
8	在这种内存分配方案中，执行速度比动态内存分配要快	在这种内存分配方案中，执行速度要比静态内存分配慢
9	编译时内存分配	运行时内存分配
10	静态分配的内存从程序开始保持到程序结束	动态分配的内存可以在任意时刻释放
11	静态的内存分配常常用于数组等	动态的内存分配常常用于链表等数据结构

1.2静态分配的优缺点

优点

使用起来简单
分配和取消分配都由编译器完成
高效的执行时间
它使用栈数据结构，在栈上开辟

缺点

内存浪费问题
必须知道确切的内存需求
一旦初始化后，内存的大小不能调整

1.3动态分配优缺点

优点

动态分配是在运行时进行的
只要我们需要，我们就可以分配（创建）额外的存储
只要我们使用结束了，内存就可以被取消分配（free / delete）动态空间；因此，人们总是可以准确地拥有所需的空间量--不多也不少。
如果需要，内存大小可以重新分配

缺点

由于内存是在运行时分配的，因此需要更多的时间。
当完成后，内存需要由用户释放。这一点很重要，因为它更有可能变成难以发现的 bug。

二、动态内存函数的介绍

C语言提供了三个动态内存开辟的函数：malloc、calloc、realloc

使用时我们要包含头文件：#include<stdlib.h>

2.1malloc和free

void* malloc (size_t size);（开辟大小单位是字节）

cplusplus网站上的介绍

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

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

举个例子：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>int main()
{//申请int* p = (int*)malloc(20);if (p == NULL){printf("%s\n", strerror(errno));return 1;}//使用int i = 0;for (i = 0; i < 5; i++){p[i] = i + 1;}for (i = 0; i < 5; i++){printf("%d ", p[i]);}//释放free(p);p = NULL;return 0;
}

仔细观察我们可以看到为什么最后多了两行代码？这个free有什么用？

这是C语言提供的另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

cplusplus网站上的介绍

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

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

再看个例子：

int main()
{//代码1int num = 0;scanf("%d", &num);int arr[num] = {0};//代码2int* 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所指向的动态内存ptr = NULL;//置空避免了野指针return 0;
}

上面代码中使用的errno能打印出错误信息。介绍一下它的使用方法

2.2calloc

calloc 函数原型如下：

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

cplusplus网站上的介绍

举个例子：

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

运行后：

再看一个：

int main()
{int* p = (int*)calloc(10, sizeof(int));if (p == NULL){printf("calloc()-->%s\n", strerror(errno));return 1;}//使用int i = 0;for (i = 0; i < 10; i++){printf("%d ", p[i]);}//释放free(p);p = NULL;return 0;
}

运行后：

所以当我们要对申请的内存空间的内容初始化，就可以使用calloc函数来完成任务，方便快捷。

2.3realloc

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

cplusplus网站上的介绍

函数原型如下：

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

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

情况1
当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2
当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

扩展步骤：

realloc会找更大的空间
将原来的数据拷贝到新空间
释放旧的空间
返回新空间的地址

由于上述的两种情况，realloc函数的使用就要注意一些。

举个例子：

int main()
{int* p = (int*)malloc(20);if (p == NULL){printf("%s\n", strerror(errno));return 1;}//使用int i = 0;for (i = 0; i < 5; i++){p[i] = i + 1;}int* ptr = (int*)realloc(p, 40);if (ptr != NULL){p = ptr;//使用for (i = 5; i < 10; i++){p[i] = i + 1;}for (i = 0; i < 10; i++){printf("%d ", p[i]);}}//释放free(p);p = NULL;return 0;
}

成功增加20个字节。

到这里我们考虑下，是不是增加多大的空间都可以？

注意：

使用动态内存函数分配空间后，要判断返回值是否为NULL，最后要记得释放并置为NULL。

三、常见的动态内存错误

下面我们来看看在动态内存使用时的错误，知晓其错误原因，并在以后避免发生这种错误。

3.1对NULL指针的解引用操作

int main()
{int* p = (int*)malloc(NULL);//可能会出现对NULL指针的解引用操作//所以malloc函数的返回值要判断的int i = 0;for (i = 0; i < 5; i++){p[i] = i;}free(p);p = NULL;return 0;
}

运行后我们发现会出错，解引用后要对值判断。

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

int main()
{int* p = (int*)malloc(20);if (p == NULL){printf("%s\n", strerror(errno));return 1;}//可能会出现对NULL指针的解引用操作//所以malloc函数的返回值要判断的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 = NULL;return 0;
}

我们观察可以看到，开辟了20个字节，使用时却使用到了40字节，越界访问了，出现错误。

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

//对非动态开辟内存使用free释放
int main()
{int arr[10] = { 1,2,3,4,5 };int* p = arr;//....free(p);p = NULL;return 0;
}

我们在使用时也要注意free是对动态内存函数释放。

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

//使用free释放一块动态开辟内存的一部分
int main()
{int* p = (int*)malloc(40);if (p == NULL){printf("%s\n", strerror(errno));return 0;}int i = 0;//[1] [2] [3] [4] [5] [ ] [ ] [ ] [ ] [ ] for (i = 0; i < 5; i++){*p = i + 1;p++;}//释放free(p);p = NULL;return 0;
}

开辟多少，释放多少。

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

//对同一块动态内存多次释放
int main()
{int*p = (int*)malloc(20);if (p == NULL){return 1;}//使用// free(p);//p = NULL;//释放free(p);p = NULL;return 0;
}

释放多次造成错误

如果释放一次就置为空，第二次释放就不会出现错误。

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

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

使用后要记得释放，如果比释放，最终在程序结束后也会被操作系统收回。

忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记：
动态开辟的空间一定要释放，并且正确释放

四、C/C++程序的内存开辟

细心地我们会发现这个图怎么跟上面的不一样，其实这里的栈对应的就是栈区，存放局部变量和函数的形参等；堆对应的就是堆区，存放的是动态内存开辟（malloc、calloc、realloc）；数据段对应的就是静态区，存放的是静态变量和全局变量。

C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码

通过上图我们也能更好的理解static关键字修饰局部变量

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

五、柔性数组

5.1柔性数组概念

柔性数组（flexible array）

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

举个例子

{int i;int a[0];//柔性数组成员
}type_a;

有些编译器会报错无法编译可以改成：

typedef struct st_type
{int i;int a[];//柔性数组成员
}type_a;

注意:

柔性数组成员前面必须至少包含一个其他成员

5.2柔性数组的特点

结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

typedef struct st_type
{int i;int a[0];//柔性数组成员
}type_a;int main()
{printf("%d ",sizeof(type_a));return 0;
}

我们可以看到sizeof 返回的这种结构大小不包括柔性数组的内存

5.3柔性数组的使用

使用时我们要记住包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

struct S
{int n;char c;int arr[0];//柔性数组成员
};int main()
{struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));if (ps == NULL){printf("%s\n", strerror(errno));}//使用ps->n = 100;printf("ps->n = %d\n", ps->n);ps->c = 'a';printf("ps->c = %c\n", ps->c);int i = 0;for (i = 0;i < 10;i++){ps->arr[i] = i;}for (i = 0;i < 10;i++){printf("%d ", ps->arr[i]);}free(ps);ps = NULL;}

柔性数组成员arr，相当于获得了10个整型元素的连续空间

5.4柔性数组的优势

struct S
{int n;char c;int arr[0];//柔性数组成员
};int main()
{struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));if (ps == NULL){printf("%s\n", strerror(errno));}//使用ps->n = 100;printf("ps->n = %d\n", ps->n);ps->c = 'a';printf("ps->c = %c\n", ps->c);int i = 0;for (i = 0;i < 10;i++){ps->arr[i] = i;}for (i = 0;i < 10;i++){printf("%d ", ps->arr[i]);}free(ps);ps = NULL;}

向上面一样使用柔性数组，有两个好处

1.方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉

2.有利于提高访问速度