指针数组和数组指针：
指针数组：
是由指针变量组成的数组，它的成员都是类型相同的指针变量。
int* arr[10]
数组指针：
专门用于指向数组的指针就叫做数组指针；
int (*arrp)[长度]
注意：一般在使用堆内存时，可能会使用它们来定义二维数组
数组与数组名
数组名就是一种特殊的指针，它是常量，不能修改它的值，它与数组的内存首地址之间是映射关系，它是没有自己的存储空间。
数组名 == &数组名 == &数组名[0]
指针变量有自己的存储空间，指针变量是可以被修改的，如果指针变量中存储的是数组的内存首地址，那么指针变量可以当成数组一样使用
数组名也可以当做指针一样使用
数组名[i] == *(数组名+i)
*(指针名+i) == 指针名[i]
数组作为函数参数时蜕变成指针传递过去，所以长度才会丢失
void func(int arr[],int len)
void func(int* arr,int len)
二级指针
指向指针的指针就是二级指针，里面存储的是指针变量的地址
定义：
类型** 指针名_pp;
赋值：
指针名_pp = &指针变量；
解引用：
* 指针名_pp <=> 指针变量；
* *指针名_pp <=> *指针变量 <=> 普通变量
注意：当需要共享指针变量时，就必须使用二级指针
函数指针：
函数名本身就是一个地址（整数），他代表了本函数在代码段中的位置
专门用于指向函数的指针就叫做函数指针，里面存储的是函数在代码段中的首地址
返回值(*函数指针名p)(参数列表)；//注意参数名不写
int scanf(const char* format, ...);
重定义scanf函数指针类型
typedef int(*funcp)(const char*, ...);
funcp fp;//fp是scanf函数指针变量
回调
把A函数指针作为B函数的参数传递给B函数，这样做就叫做函数回调
#include <stdio.h>
void swap(int** x, int** y)
{
int* tmp;
tmp = *x;
*x = *y;
*y = tmp;
}
int main(int argc, const char* argv[])
{
int num1 = 1234, num2 = 5678;
int* p1 = &num1, * p2 = &num2;
swap(&p1, &p2);
printf("%d %d \n", num1, num2);
printf("%d %d \n", *p1, *p2);
}
堆内存：
什么是堆内存：
进程的一个内存段（text、data、bss、heap、stack），由程序员手动管理
优点：足够大、内存的申请释放受控制
缺点：需要手动管理，使用麻烦
为什么要用堆内存：
1、随着程序的复杂，数据量变多
2、其它内存段的申请、释放不受控制，堆内存的申请、释放是受控制的
如何使用堆内存：
C语言中没有能够控制堆内存的语句
#include <stdlib.h>
void* malloc(size_t size);
·功能：从堆内存中申请size个字节的内存，申请到的内存中是什么还不确定
返回值：申请成功返回申请到的内存的首地址，失败返回NULL
void free(void* ptr);
·功能：释放一块堆内存
ptr：想要释放的堆内存的首地址
·注意：不能释放非法地址，不能连续释放，但是空指针可以free,还能连续free(NULL)
·注意：释放的仅仅是所有权，里面的数据不会被清理
void* calloc(size_t nmemb, size_t size);
·功能：从堆内存中申请nmemb块size个字节的连续的内存
返回值：申请成功返回申请到的内存的首地址，失败返回NULL
·注意：申请到的依然是一块连续的内存，申请到的内存会被初始化为0
void* realloc(void* ptr, size_t size);
·功能：改变已有堆内存的大小，
ptr：要调整的堆内存的首地址
size：调整后的字节数
返回值：返回调整后的内存首地址
·注意：一定要重新接收调整后的内存首地址，有可能不是在原位置是调大调小
如果无法在原位置调整大小：
1、申请一块新的符合调整后大小的内存块
2、把原内存中内容拷贝到新内存去
3、把原内存释放掉，同时返回新内存块首地址
malloc 的内存管理机制：
当首次向malloc申请内存时，malloc会向操作系统申请内存。操作系统会直接分配33页（一页 = 4096字节）内存给
malloc管理，但不意味着可以越界访问，因为malloc会把剩下的内存分给其他人，这样就可能产生脏数据
每个堆内存块之间有一些空隙（至少4字节），这些空隙一部分是为了内存的对齐，其中有4字节是为了记录
malloc必要的维护信息，这些维护信息记录了下次分配内存的位置，如果维护信息被破坏会影响下一次malloc
和free的调用
堆内存越界有什么后果？
·一切正常
·脏数据
·段错误
·影响下一次malloc和free
使用堆内存需要注意的问题：
·内存泄漏：
内存无法使用，也无法释放，而再次使用时只能重新申请，然后又泄漏，重复以上过程，长期以往导致系统中可用内存越来越少
注意：程序一旦结束，属于它的所有资源都会被操作系统回收
·如何避免内存泄漏：
谁申请的谁释放，谁知道该释放谁释放
·如何定位内存泄漏：（上网查一下）
1、查看内存的使用情况
（win任务管理器 Linux ps - aux）
2、分析代码，借助一些分析代码的工具mtrace检查malloc和free的调用情况
3、封装malloc和free，把他们的调用过程记录到日志
·内存碎片
已经释放但是又无法使用的内存就叫内存碎片，是由于内存的申请和释放时间不协调导致的
无法避免，只能尽量减少
·如何减少内存碎片的产生
1、尽量使用栈内存
2、尽量的申请大块内存自己管理
3、不要频繁申请释放内存
内存清理函数：
·bzero
#include <strings.h>
void bzero(void* s, size_t n);
功能：把一块内存清理为0
s:内存块的首地址
n:要清理为0的内存字节数
·memset
#include <string.h>
void* memset(void* s, int c, size_t n);
功能：把内存块按字节设置为c
s : 内存块的首地址
c : 想要设置的值
n : 想要设置的字节数
返回值：设置成功后的内存首地址
注意：每个字节设置成c
堆内存如何申请二维数组：
int* arrp = malloc(40);
·指针数组
int* arr[m];
for (int i = 0; i < m; i++)
{
arr[i] = malloc(n);
}
申请m行n列的二维数组
注意：每一行的n值可以不同，可以申请不规则的二维数组
释放时需要单独释放每一行
对内存要求较低，容易产生内存碎片
·数组指针
类型名 (*arrp)[列数] = malloc(sizeof(类型)*列数*行数)；
对内存要求更高，但不容易产生内存碎片
注意：无论使用哪个，访问二维数组中的成员时，只需要像访问普通二维数组一样既可
练习1：
计算出100-1000之间的所有素数，结果存储在堆内存中，不能浪费内存
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
bool sushu(int a)
{
for (int i = 2; i <= a / 2; i++)
{
if (a % i == 0)
{
return false;
}
}
return true;
}
int main(int argc, const char* argv[])
{
int* arrp = NULL, cnt = 0;
for (int i = 100; i <= 1000; i++)
{
if (sushu(i))
{
arrp = realloc(arrp, (cnt + 1) * 4);
arrp[cnt++] = i;
}
}
while (cnt--)
{
printf("%d ", arrp[cnt]);
}
return 0;
}
1、堆内存和栈内存的区别
是什么，有什么用，优缺点，注意事项
谁管理，大小，使用，安全性
2、堆内存越界的后果
脏数据
超过33页产生段错误
破坏了malloc的维护信息，会影响下一次的malloc和free
3、什么是内存泄漏、如何定位内存泄漏
由于程序的业务逻辑问题或者粗心大意导致使用完的内存没有释放，当再次需要时又重新申请，又继续没释放，长期如此导致可用
内存越来越少，系统越来越慢甚至崩溃，这种情况叫做内存泄漏
1、Windows查看任务管理器，Linux通过ps命令，可用用过GDB调试查看内存使用情况
2、借助mtrace工具分析malloc和free代码使用情况
3、封装malloc和free，记录调用情况
4、什么是内存碎片，如何尽量减少内存碎片
已经释放的，但又无法使用的内存，由于申请释放的时间大小不协调导致的，
1、尽量使用栈内存
2、申请大块内存自己管理
3、不要频繁申请释放堆内存