标准C语言基础知识8

什么是指针：
    指针是一种特殊的数据类型，使用它可以定义指针变量，指针变量中存储的是整形数据，代表了内存的编号，
    通过这个编号可以访问对应的内存

为什么要用使用指针：
    1、函数之间相互独立，但有时候需要共享变量
        传参是单向值传递
        全局变量容易命名冲突
        使用数组还需要传递长度
        命名空间是独立的，但是地址空间是同一个，所以指针可以解决这个问题
    2、由于函数之间传参是值传递(内存拷贝)，对于字节数较多的变量，值传递效率较低，
    如果传递的是变量的地址只需要传递4\8字节，可以提高传参效率
    3、堆内存无法取名字，它不像data、bss、stack内存段可以让变量名与内存之间建立
    联系，只能使用指针记录堆内存的地址，以此来使用堆内存

如何使用指针：
    定义：类型* 变量名_p;
        1、指针变量与普通变量的用法是有很大区别，建议在取名时以p结尾加以区分
        2、指针的类型表示存储的是什么类型数据的地址，它决定了通过这个指针变量
        可以访问的字节数
        3、一个*只能定义一个指针变量
        int* p1,p2,p3;  //  只有p1是指针变量,p2 p3是int
        int *p1,*p2,*p3;    // p1 p2 p3都是指针变量
        4、指针变量与普通变量一样的是默认值是随机的，一般都要初始化为NULL
    
    赋值：  变量名_p = 地址; //必须是有权限且有意义的地址
        指向栈内存：
            int* p = #
        指向堆内存：
            int* p = malloc(4);
    
    解引用：    *变量名_p;
        通过指针变量中记录的内存编号去访问内存，该过程是可能产生段错误，
        根源是由于赋值时存储了一个非法的内存编号
        *p <==> num
        注意：解引用时访问的字节数取决于定义指针变量时的类型
    
    练习1：实现一个变量的交换函数，调用它对一个数组进行排序
    int a=10,b=20;
    func(int *p1,int *p2)
    a=20,b=10;

    练习2：实现一个函数，计算两个整数的最大公约数、最小公倍数，return返回最大公约数，最小公倍数用指针处理
    3 6 3
    3 6 6
    int max_min(int num1,int num2,int* p)

使用指针需要注意的问题：
    空指针：值为NULL的指针变量叫做空指针，如果进行解引用就会产生段错误
        NULL会作为错误标志的一种，当一个函数的返回值是指针类型时，函数如果指行出错返回值就是NULL
        如何避免空指针带来的段错误
            使用来历不明的指针前先做判断
            1、从函数中获取的指针返回值，可能是空指针
            2、当函数的参数是指针，别人传给你的就可能是空指针
            if(NULL == p)
            if(!p)

    注意：NULL在绝大多数系统中是0，个别系统是1

    野指针：指向不确定的内存空间
        解引用野指针的后果
            1、一切正常
            2、脏数据
            3、段错误
        野指针比空指针的危害更严重，因为野指针无法被判断出去，而且可能是隐藏性的错误短时间不暴露
        所有的野指针都是程序员自己制造出来的，如何避免产生野指针：
            1、定义指针变量时一定要初始化
            2、函数不要返回栈内存的地址
            3、指针指向的内存释放后，指针变量要及时置空

指针的运算：
    指针变量中存储的是整型，理论上整型数据可以使用的运算符它都可以使用，但是大多数都是无意义
    指针 + n    指针+指针类型字节数*n   前进了n个元素
    指针 - n    指针-指针类型字节数*n   后退了n个元素
    指针 - 指针 （指针-指针）/类型字节数    计算出两个指针之间间隔了多少个指针元素
    注意：指针相减，指针类型必须一致

const与指针:
    当我们为了提高传参效率而使用指针时，传参的效率提高了，但是变量被共享后有了被修改的风险，
    可以借助const保护指针所指向的内存。
    const int* p;   保护指针所指向的内存不被修改
    int const *p;   同上
    int* const p;   保护指针变量不能修改
    const int* const p; 指针变量和指针所指向的内存都不能修改
    int const* const p; 同上

指针数组与数组指针：
    指针数组：
        就是由指针变量组成的数组，它的成员是指针变量
        int* arr[10];
    数组指针：
        专门指向数组的指针
        类型 （*arr）[长度]
        int （*arr）[10];

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

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

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

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

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

    函数指针可以当做函数使用
    定义函数指针：
    返回值(*指针变量名)(类型1，类型2，...);
    赋值：
        指针变量名 = 函数名;
    调用函数：
        指针变量名(实参);
    
    通过函数指针，把函数当做参数一样传递给另一个函数使用，这就是回调

    134513504    int scanf(const char *format, ...);

    #include <stdlib.h>  void qsort( void *buf, size_t num, size_t size, int (*compare)(const void *, const void *) );、

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

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

    1 1 2 3 5 8
    练习1：尝试使用递归计算第N项斐波那契数列

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

什么是堆内存：
    是进程的一个内存段(text\data\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);
    功能：申请nmenb块，每块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、尽量申请大块的内存自己管理