内存泄漏和解决办法

指针数组和数组指针:
    指针数组:
        是由指针变量组成的数组,它的成员都是类型相同的指针变量。
        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、不要频繁申请释放堆内存

上一篇:new和malloc的区别


下一篇:拨开由问题《linux下malloc最大可申请的内存》带来的重重疑云