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
2.1malloc和free
void* malloc (size_t size);（开辟大小单位是字节）
cplusplus网站上的介绍 
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
- 如果开辟成功，则返回一个指向开辟好空间的指针。
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
- 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
举个例子：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
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()
{
//代码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所指向的动态内存
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.有利于提高访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。
看到最后这里，如果觉得本文还不错，希望可以点个赞哦！！！如有不对之处，也欢迎大家给我留言交流！！！❥(^_-)
