指针与数组，函数递归，堆内存

什么是指针

  类型定义指针变量整型数据代表了内存编号

为什么要使用指针

  1、函数之间需要共享变量、输出参数

  2、提高传参效率（指针变量4/8字节）

  3、使用堆内存时

如何使用指针：

  定义： 类型* 变量名_p

    变量名以p结尾，与普通变量以示区分

    一个*不能连续定义指针变量

    初始化为NULL

    类型决定了能访问的字节数

  赋值： 变量名_p = &变量名 或者 malloc（4）

    也可以在定义时直接赋值

注意：地址必须有权限且有意义

  解引用：*变量名_p;

    通过指针变量中存储的整数地址去访问对应的内存数据

    该过程可能产生段错误，是由于赋值时错误地址导致的

使用指针需要注意的问题：

空指针：

  值为NULL的叫做空指针

  对空指针解引用时回产生段错误，因此对于来历不明的指针解引用前要先判断

  if（NUL == p）

  1、判断函数返回值

  2、判断指针参数

用空指针作为一种错误标志，如果函数的返回值是NULL表示该函数执行出错

野指针：

  值是不确定的叫做野指针

  对野指针解引用后果：

    1、一切正常

    2、脏数据

    3、段错误

  野指针危害比空指针大，因为野指针无法被判断，而且错误可能是隐藏的

  如何不产生野指针：

    1、定义指针变量时一定要初始化，一般为NULL

    2、函数不要返回局部变量的地址

    3、当指针指向的内存被销毁时，指针要及时置空

指针的运算：

​ 指针变量只有以下运算是有意义的：

​ 指针 + n 前进n个元素

​ 指针 - n 后退n个元素

​ 指针 - 指针 计算出两个指针变量之间间隔了多少个元素，只有类型相同才能相减

指针与 const

​ int const* p； 同下

​ cnost int* 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 ，。。。）

  赋值：

    指针变量名 = 函数名；

  调用函数：

    指针变量名（实参）；

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

函数递归：

  函数自己调用自己的行为叫做递归，可能导致出现死循环的效果

  递归可以实现一种叫做分治的算法思想，把一个复杂的大问题，分解成若干个相同的小问题，直到问题全部解决

  1、设置出口

  2、解决一个小问题

  3、调用自己

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

#include <stdio.h>
int func(int num)
 {
 
     if(1 == num || 2 == num)
     {
         return 1;
     }
     return func(num-1) + func(num-2);
 }
 int main(int argc,const char* argv[])
 {
     int num =0;
     scanf("%d",&num);
     printf("第n项是：%d",func(num));
 }

  递归函数每次调用自己都会在栈内存产生一份自己的拷贝，直到到达出口，才一层层释放，因此递归非常耗费内存，与循环相比速度非常慢，能用循环解决的问题就不要使用递归

  递归的优缺点：

    1、耗费内存、速度慢

    2、好理解、思路清晰

    3、可以解决非线性问题的执行过程

堆内存：

什么是堆内存：

  是进程的一个内存段（text、data、bss、stack、heap），由程序员手动管理的

  特点是足够大，缺点是使用比较麻烦

为什么要使用堆内存：

  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);
//功能：申请nmemb块，每块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、查看内存的使用情况

      （windows任务管理器 Linux ps -aux命令）

    2、分析代码、分析代码的工具检查malloc的调查情况

    3、封装malloc、free，记录申请和释放的信息到日志中，如果次数相同，则没

有泄漏，否则可能产生泄漏

内存碎片：

  已经释放但也无法继续使用的内存叫做内存碎片，由于申请和释放的时间不协调导致

的，这种情况无法避免，只能尽量减少

  如何尽量减少内存碎片

    1、尽量使用栈内存

    2、不要频繁地申请和释放内存

    3、尽量申请大块的内存自己管理