dynamic_memory_allocation(动态内存分配)
Dynamic Memory Allocation（动态内存分配）
1.为什么存在动态内存分配
2.动态内存函数的介绍
malloc
free
calloc
realloc
3.常见的动态内存错误
4.几个经典的笔试题
5.柔型数组
在开始之前，我们需要回顾一下 我们当前所掌握的 内存使用方法
当前我们知道的内存使用方法
1. 创建一个 变量
int a =10;// （假设）局部变量 - 栈区
int g_a =10; // （假设）全局变量 - 静态区
2. 创建 一个数组
局部变量 - 栈区
全局变量 - 静态区
程序一：
#include特点：
1. 空间开辟大小是固定的
2,数组 在申明 的时候，必须制定数组的长度，它所需要的的内存 在 编译时 分配
C语言是可以创建变长数组 - c99 中增加了（vs不支持，gcc支持 c99标准 -> gcc test.c - std = c99）
下面正式进入正文:
为什么存在动态内存分配？
对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行的时候才知道
那数组的编译时开辟空间的方式就不能满足了，这时候就只能试试动态开辟了（在堆上申请空间）
动态内存函数的介绍
malloc 和 free
malloc ：void* malloc(size_t size); // size 开辟的空间大小，单位字节； void* 是一个指针， 指向的是开辟的空间的起始地址
free：void free(void* memblock); // memblock - 内存块
程序二：
#include
说到 free 函数， free 函数 是专门用来做 动态内存 的 释放 和 回收 的
程序三:
#include为了方便你们进一步了解 free 函数
举个 special 例子：
你呢，跟你 girlfriend 前期 相处非常好，你把女友电话记得牢牢的，有助于交流。
但是，有一天 你女朋友看不上你了，就 free（p） [ 跟你分手了 ]
但是你（p）还死皮赖脸的记住你前女友的号码（动态开辟空间的地址），随时可能打电话骚扰她，并且找到她，影响她的生活，说明你很危险（访问该空间内容，并修改，该指针很危险）
这时候，你前女友为了你能断开念想 (其实保护自己 == 维护程序安全)
你前女友 给你当头一棒（爆头），让你失忆了。（p = NULL）
我只能说 杀人诛心！！！(还好我单身，暂时不用担心被爆头的危险。)
calloc 函数 ：void* calloc (size_t num,size_t size);
num 元素个数，size每个元素的长度【大小】（字节）
1. 函数的功能是:开辟一块空间 num*size ( num 个 大小为 size 的 元素) ，并且把空间的每个字节初始化为 0
2.与函数 malloc 的区别 只在于 calloc 会在返回 地址之前 把申请的空间的 每个字节初始化为全0
程序四：
用法跟 malloc 函数差不多
#include
realloc 函数 ： void* realloc (void* memblock,size_t size);
memblock - 内存块 (指针 指向 之前已经开辟了的内存块)
size : 新的大小
1. realloc 函数 的 出现 让动态内存管理更加灵活
2. 有时我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了， 为了合理的使用内存，我们一定会对 内存的大小 做灵活的调整， realloc 函数就可以做到 对 动态开辟内存 大小的调整。
3. memblock 是要调整的内存块的地址
4.size 调整之后 新空间的大小
5.返回值为 调整之后的内存起始位置
6.这个函数调整 原内存空间大小 的基础上，还会将原来内存中的数据移动到 新 的空间
7.realloc 在 调整内存空间 时，存在两种情况：
程序五：
#include
解决方案：
程序六：
#includerealloc 如果 p 指向的空间之后 有 足够的内存空间可以追加，则追加上，返回原先的旧地址（p）
如果 p 指向的空间之后 没有 足够的内存空间可以追加，则重新找一个新的内存区域，开辟一块新的空间， 来满足你对空间需求，同时把 原来内存 的 数据 拷贝下来，把拷贝下来的数据放到新空间里，且把原来的空间释放，最后返回新空间的地址
另外再补充一点
realloc 函数 可以实现与 malloc 函数 一样的功能
程序七：
#include
常见的动态内存错误
1. 对 NULL 指针的解引用 操作
程序八：
#include
2，对动态开辟的内存 的 越界访问
程序九：
#include
3， 对 非动态 开辟内存使用 free（释放）函数
程序十：
#include
4.使用 free 释放动态开辟内存的一部分
程序十一：
#include
5. 对同一块 动态内存 的多次释放
free 释放 一块动态开辟空间后，那个 空间 的地址并没有改变，此时再 free 就可能出现问题
程序十二：
#include
6. 对动态开辟内存 忘记释放（内存泄露）
这种错误的出现，会导致计算机内存被耗干，导致卡死，毕竟计算机内存有限
程序十三：
#include
接下来我们来看几道面试题，来加深我对 动态内存分配 函数的 理解
题目 1
程序十四：
#include附加 printf 程序 ： printf("%s\n", str) == printf(str)
程序十五：
#include
现在 我们开始 帮助 这个卧底 证明他的身份了（修改程序）
改正1
程序十六：
#include
改正2
程序十七：
#include
题目 2
程序十八：
#include
题目 3
程序十九：
#include
题目 4
程序二十：
#include
柔型数组
在 c99 标准中，结构中的最后一个元素允许是未知大小的数组，这叫做 柔型数组 成员
柔性数组的 特点：
1.结构体中的柔型数组成员前面必须至少一个其他成员
2.sizeof 返回的这种结构大小不包括柔型数组的内存
3.包含柔型数组成员的结构 用 malloc 函数 进行内存的动态分配，并且分配的内存 应该大于 结构的大小，以适应 柔型数组 的 预期大小
程序二十一：
#include因为编译器的原因，可能有一种写法不支持，这时可以写另一种写法
柔性数组的使用
程序 二十二：
#include
程序 二十三 (替代柔型数组的方法)：
#include
那么 柔型数组 和 替代方法 有何区别
我们先来对比一下：
柔性数组方法里（在 c99 标准中），在计算 结构体大小时，是没有包含 arr 数组的大小,而且开辟空间之前，我们主动算一个大小，把 n 和 数组arr 的大小（空间），一次性开辟成功，再交由 ps（接收开辟动态空间的地址） 来维护，柔性数组 其实是 把 n 和 数组arr 开辟到一块连续的空间里）
而 第二种方法: 先 malloc 创建这个结构体 空间（包含 n 和 arr），然后 再由 malloc 开辟出一个动态空间，将其地址嫁给 指针变量 arr，（ malloc 开辟了二次动态空间）
区别:
柔性一次性开辟好空间， 替换的方法 需要 二次
意味着释放（free）动态空间的时候，柔性 一次释放，替换的方式需要 二次
那么就是说 在替换方法中 malloc 开辟的动态空间越多， free也就越多，就很有可能会出现 忘记释放动态空间 而造成 内存泄漏 的问题，或者说 释放 错误对象 的 空间
而 在柔性数组中，只需要 malloc 一次，free也只需要一次，这样出错概率小
注意 malloc 函数 在开辟空间的时候，它觉得那个空间是空的，就在那里开辟空间
这样开辟开辟的方式，必然会导致 内存 里面 会有一些 空间 不大不小，导致无法使用，而造成空间的浪费（内存碎片）
内存碎片 越多，空间利用率 越差。（malloc 用的越多，出现内存碎片概率就越高，空间的利用率越低）
所以 使用 柔性数组，出现的内存碎片的概率很低，空间利用率高。
替换柔性数组的方法： 根据 malloc 函数的 特性：它觉得那个空间是空的，就在那里开辟空间
它所创建 空间 不是连续的（就是 a 这里 我创建一块，b哪里创建一块空间，在内存上 两者之间并不相连[连续]，）
柔性数组 ： n 和 arr 都在一块连续的内存块 上存储 （在一块连续的内存块上，访问内存 的 效率更高）
在这里我们先来了解一些东西
存储器 - 金字塔层次结构：越靠近CPU速度越快，容量越小，价格越贵
金字塔层次结构
当 CPU 处理数据的时候 ，从寄存器里拿，因为它更快。
这时候我们就会把 内存的数据 ， 放到 高速缓存 里，高速缓存的数据 放到 寄存器 里 。CPU 在往 寄存器里拿，数据最终都是来自于内存
局部性原理：
时间局部性(temporal locality)：如果一个数据被访问了，那么它在短时间内还会被再次访问。如 LRU 缓存机制，将频繁访问的数据保存在内存中。
空间局部性(spatial locality)：如果一个数据被访问了，那么和它相邻的数据也很快会被访问。如果数组的 CPU 预读功能。
在这里我们只需了解一下，不必太过深入
当我们访问一个内存（空间）数据的时候，接下来 80% 的可能性，你访问是它周边的 数据。
内存中，如果我们存放数据的时候，是连续存放的话，那么接下来，我们就把这些连续的数据 放到 寄存器 里，这样我们的命中率就提升了，这时候计算机的访问效率更高些。
也就是说 替换柔型数组的方法 ，开辟 的 两个 空间 并不连续，所在访问是可能 第一次访问不到，因为 太分散了（不连续）
意味着 cpu 往寄存器里拿，很有很有可能拿不到我们想要的，它就往 高速缓存 里面拿，高速缓存没有，就往内存里拿.
这样我们命中率大大下降，计算机的访问的效率更低。
柔型数组的优点：
1.开辟一块连续的空间,命中率就提升，计算机的访问效率更高。
2.出现 内存碎片 的 概率很低，空间利用率高。
3.只需要 malloc 一次，free也只需要一次，这样出错概率小（忘记释放动态内存，或者释放错误的空间对象）
所以综合来说 来说：
柔型数组的优点就是：方便内存释放，访问速度更快。