2021.7.21标准C语言

复习：
什么是指针：
类型 定义指针变量 整型 内存编号

为什么要使用指针：
    1.函数之间共享变量时、输出函数
    2.提高传参变量（指针变量4/8字节）
    3.使用堆内存时，必须要配合指针

如何使用：
    定义：类型* 变量名_p;
        变量名以p结尾，与普通变量以示区分
        一个*不能连续定义指针变量
        初始化为NULL
        类型决定了能访问的字节数
    
    赋值： 变量名_p = &变量名; | malloc(4)
            也可以在定义时直接赋值
            注意：地址必须有权限有意义

    解引用： *变量名_p;
        通过指针变量中的存储的整数地址去访问对应的内存数据
        该过程可能产生段错误，是由于赋值时非法地址导致的

使用指着需要注意的问题：
    空指针：
        值为NULL的叫做空指针
        对空指针解引用时会产生段错误，因此对于来历不明的指针，解引用前先要判断
            if(NULL == p)
                1.判断函数返回值
                2.判断指针参数
        用空指针作为一种错误标志，如果函数的返回值为NULL，表示该函数执行出错

    野指针：
        值是不确定的叫做野指针
        对野指针解引用引用的后果：
            1.一切正常 2.脏数据 3.段错误
        野指针危害比空指针大，因为野指针无法被判断，而且错误可能是隐藏的
            如何不产生野指针：
                1.定义指针变量时一定要初始化，一般NULL
                2.函数不要返回局部变量的地址
                3.当指针指向的内存被销毁时，指针要及时置空

指针的运算：
    指针只有以下运算是有意义的：
    指针 + n        前进n个元素
    指针 - n        后退n个元素
    指针 - 指针     相差了几个元素，只有类型相同才能计算

指针与const:
    const int* p;
    int const* p;   保护指向的内存不被修改
    int* const p;   保护指向/指针变量不能修改
    const int* const p;
    int const* const p; 既保护内存又保护指向不能修改

指针数组与数组指针：
指针数组：
就是由指针变量组成的数组，它的成员是指针变量
int* arr[10];

数组指针：
    专门指向数组的指针
    int (*arr)[10];       

指针与数组名：
数组名可以看做一种特殊的指针，它是常量，不能修改它的值，数组名与数组的内存之间是映射关系，而指针变量与内存之间是指向关系，数组名是没有自己的存储空间的
数组名 == &数组名 == &数组名[0]

如果指针变量中存储的是数组的首地址，指针可以当做数组使用，数组名也可以当做指针来使用
数组名[i] == *(数组名+i)
*(p+i) == p[i]

数组作为函数的参数时蜕变成了指针，所以长度丢失

二级指针：
二级指针就是指向指针的指针，里面存储的是指针变量的地址
定义： 类型** 变量名_pp;
赋值： 变量名_pp = &指针变量;
解引用：*变量名_pp <=> 指针;
**变量名_pp <=> *指针 <=> 普通变量

函数指针：
函数名就是该函数在代码段中的内存首地址（整数）
调用函数其实就是跳转到该函数所在的代码段中去执行二进制指令
函数指针就是用来专门指向函数的指针，里面存储的时函数的首地址，对函数指针解引用就可以执行函数

函数指针可以当做函数使用
定义函数指针：
    返回值 （*指针变量名）（类型1，类型2，...）；
赋值：
    指针变量名 = 函数名；
调用函数：
    指针变量名（实参）；

通过函数指针，把函数当做参数一样传递给另一个函数使用，这就是回调

递归
函数自己调用自己的行为叫做递归，可能导致出现死循环的效果
递归可以实现一种叫做分治的算法思想，把一个复杂的大问题，分解成若干个相同的小问题，直到问题全部解决

1.设置出口 
2.解决一个小问题
3.调用自己

练习1：尝试使用递归计算第n项斐波那契数列

递归函数每次调用自己都会在栈内存产生一份自己的拷贝，直到到达出口，才一层层释放，因此递归非常耗费内存，与循环相比速度非常难，能用循环解决的问题就不要使用递归
    递归的优缺点：
        1.耗费内存速度慢
        2.好理解、思路清晰
        3.可以解决非线性问题的执行过程

作业1：
    使用递归模拟汉诺塔的移动过程

作业2：
    实现打印 0~9 的全排列

什么是堆内存：
是一个进程的内存段（text\date\bss\heap\stack），由程序员手动管理
特点是足够大，缺点是使用比较麻烦

为什么使用堆内存：
1.随着程序的复杂数据量变多
2.其他的内存段的申请和释放不受控制，堆内存的申请释放是受程序员控制的

如何使用堆内存：
注意：C语言没有控制管理堆内存的语句，只能使用标准C库中的函数
#include <stdlib.h>

    void *malloc(size_t size);
        功能：从堆内存中申请size个字节的内存，申请的内存存储的是什么内容不确定
        返回值：申请成功后返回该内存的首地址，失败会返回NULL

    void free(void *ptr);
        功能：负责释放一块堆内存，不能重复释放，也不能释放非法地址。但是可以释放NULL，并且可以重复释放
        注意：释放不会帮你清理，释放的仅仅是使用权，里面的数据不会全部清理，只会清理前4个字节为0

    void *calloc(size_t nmemb, size_t size);
        功能：申请mmenb块堆内存,每块size个字节的堆内存，申请的内存会全部初始化为0（速度慢）
        注意：申请到的依然是一块连续的内存

    void *realloc(void *ptr, size_t size);
        功能：改变已有的堆内存块的大小
        ptr:要调整的内存块的首地址
        size:调整后的字节大小
        返回值：返回的是调整后的内存块的首地址，一定要重新接受返回值，因为可能不是在原基础上进行调整
            如果无法在原地址进行调整
                1.申请出一块新的符合要求的内存块
                2.把原内存块中的内容拷贝进去
                3.把原内存块释放并返回新内存块的首地址

malloc的内存管理机制：
当首次向malloc申请内存时，malloc会向操作系统申请内存，操作系统会直接分配33页（1页 = 4096字节）内存交给malloc管理，但是不意味着可以越界访问，因为malloc会把使用权分配给“别人”，此时就会产生脏数据

每个内存块之间一定会有一些间隙（12~4字节），这些空隙一些是为了内存对齐，其中一定有4个字节记录malloc的维护信息，这些维护信息决定了下次分配内存的位置，还可以借助这些位置计算出每个内存块的大小，如果这些维护信息被破坏，就会影响下一次的malloc、free函数的调用

使用堆内存需要注意的问题：
内存泄漏：
内存无法再使用，又无法释放，而再次使用时只能重新申请，然后重复以上过程，日积月累后系统中可用的内存就会越来越少
注意：程序一旦结束属于它的所有资源都会被操作系统回收

    如何避免内存泄漏：
        谁申请，谁释放
        谁知道该释放，谁释放

    如何定位内存泄漏：（百度一下）
        1.先查看内存的使用情况
            （win资源管理器  Linux ps -aux）
        2.分析代码、分析代码的工具来检查malloc的调用情况
        3.封装malloc、free，记录申请和释放的信息到日志中

内存碎片：
    已经释放但也无法使用的内存叫做内存碎片，是由于申请和释放的时间不协调导致的，无法避免的只能尽量减少

    如何尽量减少内存碎片：
        1.尽量使用栈内存
        2.不要频繁的申请和释放内存
        3.尽量申请大块的内存自己管理