说明
这是一个完善了但又不完善的笔记，或许以后会更新
可以参考但请务必超越
源文件
Tools
VS2019
VScode
Typora
PicGo
动态内存管理
本章重点
- 为什么存在动态内存分配
- 动态内存函数的介绍
malloc
free
calloc
realloc
- 常见的动态内存错误
- 几个经典的笔试题
- 柔性数组
1.动态内存分配
C语言让我们可以想用多大空间就可以开辟多大空间，当然是能力范围内。
我们现在掌握的基本内存开辟方式：
int n = 10;//4 byte
int arr[10];//40 byte
int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间这样的开辟方式有2个特点：
- 空间开辟大小是固定的。不够灵活，不够方便
- 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是，对于空间的需求肯定不能只是以上的情况。当我们在运行程序的时候才能知道所需要的大小。这个时候就可以试试动态内存开辟了
在内存的堆区上，我们进行动态内存分配：
之后还有C/C++语言的内存分布图
2.动态内存函数
malloc和free
void* malloc (size_t size);这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
malloc函数只负责在堆区申请空间，并且返回起始地址，不初始化内存空间！
- 如果开辟成功，则返回一个指向开辟好空间的指针。
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
- 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
void free (void* ptr);free函数用来释放动态开辟的内存。
- 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
- 如果参数 ptr 是NULL指针，则函数什么事都不做。
#include <stdlib.h>
//注意头文件
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return -1;
}
//开辟成功
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
//释放空间
free(p);//虽然释放了，但是p还在，所以其实还是很危险的
p = NULL;//直接NULL就好了
return 0;
}如果free(p)之后没有给p赋值NULL，p就会变成野指针。
calloc
void* calloc (size_t num, size_t size);malloc函数只负责在堆区申请空间，并且返回起始地址，不初始化内存空间！
calloc函数在堆区上申请空间，并且初始化为0，返回起始地址！
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
printf(" % 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;
}空间不够，返回错误信息：
realloc
void* realloc (void* ptr, size_t size);- ptr 是要调整的内存地址
- size 调整之后新大小
- 返回值为调整之后的内存起始位置。
- 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
printf(" % s\n", strerror(errno));
return -1;
}
//申请成功
//设置内容
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
//空间不够了，增加空间至20个int
int* ptr = (int*)realloc(p, 20 * sizeof(int));
//增容失败，需要一个ptr来判断，不能用p接收
//p = realloc(p, 20 * sizeof(int));//err
if (ptr != NULL)
{
p = ptr;
}
else
{
return -1;
}
//设置内容
for (i = 10; i < 20; i++)
{
*(p + i) = i;
}
//打印一下看看
for (i = 0; i < 20; i++)
{
printf("%d ", *(p + i));
}
//释放空间
free(p);
p = NULL;
return 0;
}realloc在调整内存空间的是存在两种情况
- 情况1：原有空间之后有足够大的空间，直接追加
- 情况2：原有空间之后没有足够大的空间，新找一块空间，把源数据拷贝并且追加新空间
增容也是有可能失败，他也会返回空指针。并且会很尴尬。
如果前面用p来维护，后面也用p来接收，那是不行的。当增容开辟失败的时候，原来的p也没在了。
注意
无论是realloc如何增容，只要是malloc开辟的空间，都是free释放。
3.常见的动态内存错误
对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(20);
*p = 0;//直接这样写代码是有风险的！！！
//如果malloc返回了空指针，对空指针p进行解引用操作，那不就寄了。
return 0;
}所以一定要记得判断一下，建立一个良好的习惯
int main()
{
int* p = (int*)malloc(20);
if (p = NULL)
{
return -1;
}
*p = 0;
return 0;
} 对动态开辟空间的越界访问
即使可以打印出来，也是错的。
int main()
{
int* p = (int*)malloc(200);
//1个int4个字节，最多也就50个
if (p == NULL)
{
return -1;
}
//使用
int i = 0;
//80个肯定放不下
for (i = 0; i < 80; i++)
{
*(p + i) = i;
}
for (i = 0; i < 80; i++)
{
printf("%d\n", *(p + i));
}
//释放
free(p);
p = NULL;
return 0;
}虽然CTRL+F5可以正常运行，但是她就是错的。
点击F5调式就可以看到错误信息。
对非动态开辟内存使用free释放
int main()
{
int a = 10;
int* p = &a;
//释放
free(p);
//free了个寂寞
p = NULL;
return 0;
}他是在栈区上开辟的，不是堆区上。
free只释放在堆区上开辟的动态内存空间
使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
return -1;
}
//使用内存
int i = 0;
for (i = 0; i < 10; i++)
{
*p++ = i;
//p已经走远了，她压根就不能动
}
//释放
free(p);
//同样释放了个寂寞
p = NULL;
return 0;
}无论p在哪都不行，只能是起始位置，走到哪释放，都不能释放完。
对同一块动态内存多次释放
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return -1;
}
//使用
//...
//释放
free(p);
//p = NULL;//如果没有先赋值为空指针们就会变成2次释放，那肯定是不行的。赋值之后就可以了。因为free(NULL)不操作嘛。
free(p);
p = NULL;
return 0;
}动态开辟内存忘记释放（内存泄漏）
在堆区上申请的空间，有2种回收的方式
1.free
2.程序退出的时候，申请的空间也会回收
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return -1;
}
getchar();
return 0;
}可以看到，这一块内存永远都释放不了。
如果是在服务器，有一个循环的动态开辟但是不释放。内存就会一点一点被吃掉，然后卡死重启，然后又开辟空间不释放。这就是内存泄漏。
内存泄漏很重点，无论是家用桌面机还是高端旗舰机，哪怕是服务器，内存泄漏都会寄。
动态内存释放切记
动态开辟的空间一定要释放，并且正确释放
而且p最后也一定要记得赋值NULL。如果释放了p，但是没有赋值，那么p就会变成野指针
4.几个经典的笔试题
题目1：
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;
} 代码直接挂了，为什么？
1.传给p的时候，是值传递，p是str的临时拷贝，所以当malloc开辟的空间起始地址放在p中的时候，不会影响str。str依然为NULL。
2.当str是NULL，strcpy想把hello world拷贝到str指向的空间时，程序就崩溃了。因为NULL指针指向的空间时不能直接访问的。
3.代码甚至没有free。存在内存泄漏
修改
第一种改法
void GetMemory(char** p)//用char**接受
{
*p = (char*)malloc(100);//*p就是str
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//取str的地址
strcpy(str, "hello world");
printf(str);
//释放
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
} 第二种改法
char* GetMemory(char* p)//返回一个char*，实际上没有参数也可以
{
p = (char*)malloc(100);
return p;//返回
}
void Test(void)
{
char* str = NULL;
str = GetMemory(str);//str接收，实际上不传参，没有参数也可以
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}题目2：
char* GetMemory(void)
{
char p[] = "hello world";//p是一个局部数组
return p;//返回了栈空间的地址
}
void Test(void)
{
char* str = NULL;
str = GetMemory();//此时str是野指针
printf(str);
}
int main()
{
Test();
return 0;
}打印随机值，为什么？
1.局部变量是放在栈上的，return的p，是存放在寄存器上的。虽然str指向了p，但是p所维护的hello world的这块空间，返还给操作系统了。
2.这时打印str，str找回去，就是随机的。
str此时是野指针
举个栗子(经典宾馆)：
一个大学生下课太累了，没回宿舍就近找了家宾馆(hello world)。住的很舒服。然后他打电话给他的同学张三(str)，说明天你来住吧，地址是p。第二天退房走了，张三来了。房还在那，张三非要住进去，保安打死。
这类问题就是：返回栈空间地址的问题。
相似的写法：
int* test()
{
int n = 10;
return &n;
}
int main()
{
int* p = test();
printf("%d\n", *p);//10
return 0;
}
确实有可能打印出来10，但是如果再简单的添加一句代码
int main()
{
int* p = test();
printf("%d\n", *p);//10
return 0;
}
p就是野指针，虽然打印出了10，但他就是错的
一定要记得会分析，否则很容易都写出这样的bug
题目3：
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
//注意，这个地方不能free
//不用这块空间的时候，再free
//在这里就free了，那没法用了。创建了个寂寞。
}
void Test(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
//问题就出在这里，没有free，内存泄漏
//free(str);
//str = NULL;
}
int main()
{
Test();
return 0;
}题目4：
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
//在malloc开辟的空间放了一个hello
free(str);
//还给操作系统，注意，这块空间没有消失。
//如果free放在这里，那么str必须赋值为空
//否则，str就会变成野指针
if (str != NULL)
//str确实还放着这块空间的地址，那肯定不是空的
{
strcpy(str, "world");
//非法访问
//都还给操作系统了。
printf(str);
}
}
int main()
{
Test();
return 0;
}实际运行时，虽然可以看到打印出了world，但是，错的就是错的。
注意
编译器也是人写的，编译器没发现错误，并不意味着就没有错误，如果编译器能发现，要程序猿干什么。
小偷偷了东西没人发现，那偷东西的行为也是错的。
5.C/C++程序的内存开辟
C/C++程序内存分配的几个区域：
- 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
- 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
- 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
C语言内存分布图
实际上有这么一幅图可以帮助理解：
后续学习操作系统的话，可以更细致的理解。
6.柔性数组
柔性数组（flexible array）是确实存在的。在C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。
注意，这是在结构体中！
举个栗子(代码1)：
typedef struct st_type1
{
int i;//前面至少有一个其他成员
int a[];//柔性数组成员
}type_a;
typedef struct st_type2
{
int i;//前面至少有一个其他成员
int a[0];//柔性数组成员，a[0]有些编译器会报错可以改成上面的
}type_b;
int main()
{
printf("%d\n", sizeof(type_a));//只输出4
//代码1
struct st_type1* ps = (struct st_type1*)malloc(sizeof(struct st_type1) + 10 * sizeof(int));//注意理解这行代码
//总共开辟了44个字节，i一个字节，a四十个字节。malloc返回的是这44个字节整体的起始地址。
//当以后想要增容，使用realloc就可以了。
if (ps == NULL)
{
printf("%s\n", strerror(errno));
return -1;
}
//开辟成功的话，就往下走
ps->i = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->a[i] = i;
//这里使用了柔性数组
}
//打印看看
for (i = 0; i < 10; i++)
{
printf("%d ", ps->a[i]);
}
//假设a数组的空间不够了，希望调整为20个整型数据
struct st_type1* ptr = (struct st_type1*)realloc(ps, sizeof(struct st_type1) + 20 * sizeof(int));
if (ptr == NULL)
{
printf("扩展空间失败\n");
return -1;
}
else
{
ps = ptr;
}
//使用
//...
//释放
free(ps);
ps = NULL;
return 0;
}上面的例子int a[]和int a[0]他们都是柔性数组成员。前面没有其他成员那就是不支持的。打印一下sizeof也不会打印出来。
柔性数组的特点
- 结构中的柔性数组成员前面必须至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存。
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配(calloc也行)，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
柔性数组的使用
上述代码已经包含了柔性数组的使用(代码1)。
注意
思考一下，之前写动态内存增长通讯录的时候。增容无非就是不够的时候再补，假设补成二倍的空间。
使用一个指针a可以指向连续的空间，这块空间可以malloc。这时当然可以把a看成是一个数组(数组就是连续的空间嘛，当然a绝对不是数组，只是看做当做)。
对比代码1写一个代码2，也在堆上开辟，保持他们非常相似。
首先图来理解，假设i还是100。
typedef struct st_type
{
int i;//4
int* a;//4
};
int main()
{
//代码2
struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type));
ps->i = 100;
ps->a = (int*)malloc(10 * sizeof(int));
//这块空间是malloc出来的
int i = 0;
for (i = 0; i < 10; i++)
{
ps->a[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->a[i]);
}
//a指向的空间不够了，希望可以调整大小，增容了第二块空间。
int* ptr = (int*)realloc(ps->a, 20 * sizeof(int));
if (ptr == NULL)
{
printf("扩容失败\n");
return -1;
}
else
{
ps->a = ptr;
}
//使用
//...
//释放
free(ps->a);
ps->a = NULL;
//注意先把第二块空间释放，不然先释放第一块，第二块就寄了。
free(ps);
ps = NULL;
return 0;
} 柔性数组的优势
可以看到上面举栗的代码1和代码2
那么哪一个代码更好呢？
首先，他们都可以完成同样的功能
但是代码1的实现有两个好处
第一个好处：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
代码1只释放了一次。malloc了一次就释放一次，malloc的次数少就不容易出现内存泄漏或者动态内存相关的问题。而且次数越多，内存碎片越多，内存的利用率就下降了。当然以后还会涉及到内存池等
第二个好处：有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）
局部性原理。使用数据时大概率可能是使用周围的数据。寄存器，高速缓存，内存。程序会把数据放在寄存器里运行，因为寄存器最快。如果malloc次数很多，那么数据就会这一块哪里一块，就不容易在寄存器里命中，他可能跑到高速缓存甚至内存中，就会慢下来。
扩展
C语言结构体里的数组和指针：https://coolshell.cn/articles/11377.html
看的我热血沸腾啊https://www.237fa.com/