内存泄漏和解决办法

内存泄漏和解决办法

指针数组和数组指针：
    指针数组：
        是由指针变量组成的数组，它的成员都是类型相同的指针变量。
        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
            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

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
    void bzero(void* s, size_t n);
    功能：把一块内存清理为0
    s:内存块的首地址
    n:要清理为0的内存字节数
    ·memset
    #include
    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
#include
#include
        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、不要频繁申请释放堆内存