@TOC
动态内存管理
前言
动态内存管理是非常重要的，以后会用到的地方非常多，主要重点内容有：
- 动态内存函数的介绍
- malloc
- free
- calloc
- realloc
- 常见的动态内存错误
- C/C++动态内存开辟
- 柔性数组
为什么要存在动态内存分配
像我们这样平时使用的变量定义，数组定义等等，这些有以下特点：
- 空间开辟大小是固定的。
- 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，很多时候我们并不知道要使用多少，所以就引入了动态内存开辟。
动态内存函数介绍
动态内存函数开辟空间
首先要记住一点:动态内存函数开辟的空间是在堆区上
malloc和free
我们先看函数信息：
大致意思就是告诉malloc你要开辟多大内存空间，malloc给你申请，返回一个void*的指针，指向为你开辟好的空间地址。如果开辟失败则返回空指针。
我们可以用一个简单例子来说明malloc用法：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
//开辟10个整型大小
int* p = (int*)malloc(10 * sizeof(int));
//如果开辟失败打印错误信息
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
//打印开辟好的空间内容
for (int i = 0; i < 10; i++)
{
printf("%d\n", *(p + i));
}
return 0;
}
我们可以看一下打印结果：
这样写看起来是没有任何问题的，开辟好的空间里面都是随机值并且很好的打印了出来。但实际上这样是有问题的，这就要引出free函数了
我们看函数信息：
在我们malloc向操作系统申请空间在使用完之后我们最好还给操作系统，虽然从结果上来看，这个程序结束后空间也会被操作系统回收，那如果你写出的代码出现了问题一直不结束呢？所以我们最好手动释放空间，这就要用到free这个函数了，只要将地址传给free即可。除此之外我们还有一个需要注意的点：
可以看到即使我们free之后，p的值没有改变，注意这时候我们已经将空间还给操作系统了，但是p还是指向那个地址，这时候如果有胆子比较大的通过p去访问那块空间就出大问题了，这时候就是非法访问了，所以在free之后我们还需要手动将p置为空指针才行。
以上就是我们对malloc和free的分析，所以上面那个例子的正确代码应该是：
以上就是malloc和free的用法。
我们可以总结一下：
1.malloc为你申请一定大小的空间，成功则返回void*的指针，失败则返回空指针；
2.由于返回的是void*，所以需要强制转换一下才可以使用；
3.在使用完之后要使用free手动释放空间；
4.释放后要将旧指针置为空指针；
calloc
calloc和malloc其实差不多但是有几点区别：
我们先看函数信息：
和malloc类似，但是我们要告诉calloc我们需要几个元素，每个元素大小是多少，函数参数这点和malloc有些区别，我们通过代码来举例如何使用：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
//开辟10个整型空间
int* p = (int*)calloc(10, sizeof(int));
//如果开辟失败打印错误信息
if (p == NULL)
{
perror("calloc");
return 1;
}
//打印空间的内容
for (int i = 0; i < 10; i++)
{
printf("%d\n", *(p + i));
}
free(p);
p = NULL;
return 0;
}
输出：
诶，可以看到结果似乎并不是随机值，而是全部初始化为了0，没错，这也是calloc和malloc的区别，这时候我们就可以总结一下了：
以上就是calloc的介绍。
realloc
上面我们只是介绍了如何动态开辟空间，但是如果空间不够大或者过大需要调整怎么办呢，这就要用到realloc来调整了，
函数信息有些复杂，我们先简单看函数参数：
void* realloc (void* ptr, size_t size);
解释一下就是将需要调整的空间地址传过去，然后是需要调整的大小。调整成功则返回void*的指针，失败返回NULL。
但需要注意的是我们不能用旧的指针p直接接受返回值，什么意思呢？举个例子：
可以看到编译器也是给报警告了，这就是拿原来的指针直接接受，可以会造成原来空间没有回收，造成内存泄漏问题。为什么会出现这种情况呢？
我们要明白realloc的工作原理：
看懂这里我想你就明白了为什么不能直接用旧的指针来接收了，
- 第一种原因是：原来空间没有回收，会造成内存泄漏
- 第二种原因是：如果没有扩容成功，返回一个空指针原来的数据也搞丢了
所以我们只能用一个新的指针来接受realloc的返回值，然后判断不为再空赋给p，并且将p置为空指针。
正确代码如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
//开辟10个整型空间
int* p = (int*)calloc(10, sizeof(int));
//如果开辟失败打印错误信息
if (p == NULL)
{
perror("calloc");
return 1;
}
//假设我们要扩容到20个整型空间
int* str = (int*)realloc(p, 20 * sizeof(int));
if (str != NULL)
{
p = str;
str = NULL;
}
free(p);
p = NULL;
return 0;
}
关于realloc还有一点需要补充的是如果给realloc传递的为NULL，那么此时realloc的功能和malloc一样。
例如：
int* p=(int* )realloc(NULL,10*sizeof(int));
此时realloc相当于malloc。
常见的动态内存错误
对空指针的解引用操作
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
//这里一定要注意判断是否是空指针
for (int i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
这时候没有加判断是否为空的话，下面使用就有可能是野指针。
对动态开辟内存空间的越界访问
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
perror("malloc");
return 1;
}
//越界访问
for (int i = 0; i < 100; i++)
{
*(p + i) = 0;
}
free(p);
p = NULL;
return 0;
}
这段代码看起来一气呵成，但是你要是运行的话，就出问题了，你会发现程序直接挂了，卡死关都关不掉，点好几下才可以。因为这里是越界访问了，注意我们malloc开辟的空间大小是100字节，而不是100个整型的大小。
对非动态开辟内存使用free释放
#include <stdlib.h>
int main()
{
int a = 10;
int* p=&a;
free(p);
return 0;
}
对于这样非动态开辟的内存空间是不可以用free来释放的，可以看到这个程序挂的还是挺严重的，直接卡死退都退不出去。
使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
perror("malloc");
return 1;
}
for (int i = 0; i < 25; i++)
{
*p = i;
p++;//注意p移动了
}
free(p);
p = NULL;
return 0;
}
注意到p是已经移动了，我们后面free释放的是一部分空间。像这种动态内存开辟的函数你使用出问题了，大部分都是上面那种程序直接卡死的情况。
对同一块动态内存多次释放
void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
}
原因是p已经是释放过一次了，这时候p还是指向原来的位置，这时候已经是野指针了，再去free就会出问题
所以我们在第一次free时一定要将p置为空指针，下面如果再次free就不会出问题，free的参数为NULL什么事都不做。
动态开辟内存忘记释放（内存泄漏）
void test()
{
int *p = (int *)malloc(100);
if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}
这种情况一定要注意，这时候如果你发现问题，想释放都来不及了，因为在函数里面的参数一出函数就销毁了，你找都找不到那个地址。
为了避免这种情况我们要注意的有：
malloc和free一定要成对出现使用，
如果在函数内部使用且不想在函数内部释放要写清楚注释：
例如：
//test函数内部进行了malloc操作，返回了开辟空间的起始地址，记得释放
int* test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
return p;
}
int main()
{
int* ptr=test();
free(ptr);
ptr = NULL;
while (1);
}
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
C/C++程序的内存开辟
- 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
- 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
- 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
柔性数组
柔性数组定义
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员 。
typedef struct st_type
{
int i;
int a[];//柔性数组成员--有些编译器可能要写成a[0]
}type_a;
柔性数组的特点
- 柔性数组成员的前面至少有一个成员
- sizeof计算结构体大小不包括柔型数组的大小
- 包含柔型数组的结构应该用malloc动态分配内存
使用举例：
struct S
{
int n;
char arr[];//柔型数组成员
};
int main()
{
//柔型数组空间的开辟
struct S* pc = (struct S*)malloc(sizeof(int) + 10 * sizeof(char));
if (pc == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 10; i++)
{
printf("%d\n", pc->arr[i]);
}
//释放空间
free(pc);
pc = NULL;
return 0;
}
柔型数组优势
以上面例子，我们使用另外一种方式同样可以达到效果，如：
struct S
{
int n;
char* str;
};
int main()
{
struct S* pc = (struct S*)malloc(sizeof(struct S));
if (pc == NULL)
{
perror("malloc->pc");
return 1;
}
char* ps = (char*)malloc(10 * sizeof(char));
if (ps == NULL)
{
perror("malloc->ps");
return 1;
}
pc->str = ps;
ps = NULL;
for (int i = 0; i < 10; i++)
{
printf("%d\n", *(pc->str + i));
}
free(ps);
ps = NULL;
free(pc);c
pc = NULL;
return 0;
}
我们来对比一下两种方法
首先一点就是两次malloc在实际场景中肯定要比使用一次容易出错，你可能忘记释放空间或者多种情况。
其次还有一个概念叫做内存碎片，
所以我们可以总结一下，
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。第二个好处是：这样有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）
