动态内存管理（上）

动态内存管理的意义

int a =10;//固定的向内存申请四个字节
int arr[10];//申请连续的一块空间

上面这种空间开辟方式，空间开辟大小是固定的，然而有时我们需要的空间大小在程序运行时才能知道，这时候，动态内存开辟就发挥了作用。

---

动态内存函数

动态内存的管理都是在堆区上进行的，如上图。

malloc和free

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

如果开辟成功，则返回一个指向开辟好空间的指针。

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

返回值类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者自己决定。

如果参数size为0，malloc的行为标准是未定义的，取决于编译器。

另一个函数free，是专门用来释放和回收动态开辟的内存。

如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的。

如果参数ptr是NULL指针，则函数什么事也不做。

int main()
{
    //申请40字节用来存放10个整型
    int* p=(int*)malloc(40);
    if (p == NULL)
    {
        printf(" %s\n", strerror(errno));
        return 1;
    }
    //存放1~10
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *(p + i) = i + 1;
    }
    //打印
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(p + i));
    }
    //free释放申请的内存
    free(p);//free虽然可以把申请的空间还给操作系统，但却没有把p置为空指针
    //此时p仍然指向之前开辟的空间
    //若再使用p会形成非法访问
    p = NULL;//所以要手动置空
    return 0;
}

若申请开辟的空间过大，可能会失败，这时我们的strerror函数就突显作用了。

calloc

calloc函数也是用来动态开辟空间的。

num指元素个数,size指每个元素的大小。

int main()
{
    int* p = (int*)calloc(10, sizeof(int));
    if (NULL == p)
    {
        perror("calloc");
        return 1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(p + i));
    }
    free(p);//同样记得释放空间
    p = NULL;
    return 0;
}

输出结果是10个0，说明calloc申请空间后会把空间中的每个元素初始化成0，然后返回起始地址。

而malloc申请后直接返回起始地址，没有初始化，效率更高。

realloc

realloc函数的出现让动态内存管理更加灵活。

有时候我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，为了能对内存的大小做灵活调整，realloc函数就做到了对动态开辟内存大小的调整。

ptr指向之前由malloc、calloc或realloc开辟的空间,size指要调整后的新大小是多少字节。

若传的指针是空指针，则相当于开辟一块空间，功能相当于malloc。

realloc的工作原理

int main()
{
    int* p = (int*)malloc(5 * sizeof(int));
    if (NULL == p)
    {
        perror("malloc");
        return 1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        *(p + i) = 1;
    }
    //不够了，增加5个整形的空间
    int* ptr = (int*)realloc(p, 10 * sizeof(int));
    //不要用原来的指针接收传回来的地址！！！
    if (ptr != NULL)
    {
        p = ptr;
        ptr=NULL;
    }
    //继续使用空间
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(p + i));
    }
    //释放空间
    free(p);
    p = NULL;
    return 0;
}

---

常见动态内存错误

对NULL指针的解引用问题

int main()
{
    int* p = (int*)malloc(100);
    //不对返回值进行判断可能会出现问题
    //malloc返回值一定要判断
    int i = 0;
    for (i = 0; i < 20; i++)
    {
        *(p + i) = 0;
    }
    return 0;
}

对动态开辟空间的越界访问

int main()
{
    int* p = (int*)malloc(100);
    //25个整型
    if (p == NULL)
    {
        return 1;
    }
    int i = 0;
    for (i = 0; i < 100; i++)//越界访问了
    {
        //*(p + i) = 0;
        p[i]=0;
    }
    free(p);
    p = NULL;
    return 0;
}

对非动态开辟内存使用free释放

void test()
{
    int a = 10;//放在栈区
    int* p = &a;
    free(p);//只能释放堆区开辟的空间
    p = NULL;
    return 0;
}

使用free释放一块动态开辟内存的一部分

int main()
{
    int* p = (int*)malloc(100);
    if (p == NULL)
    {
        return 1;
    }
    int i = 0;
    for (i = 0; i < 25; i++)
    {
        *p = i;
        p++;//p的位置已经发生了改变
    }
    free(p);//p指向的不是动态内存空间的起始位置
    p = NULL;
    return 0;
}

对同一块动态内存多次释放

int main()
{
    int* p = (int*)malloc(100);
    if (p == NULL)
    {
        return 1;
    }
    //使用
    //释放
    free(p);//释放后p已经是野指针
    //p=NULL;
    //如果free后把p置为空指针就不会出现问题
    //.......


    free(p);//对同一块空间释放了两次
    return 0;
}

动态开辟内存未被释放（内存泄漏）

test()
{
    int* p = (int*)malloc(100);
    //使用
    //......
}

int main()
{
    test();
    //....
    //忘记释放空间，到这时想释放也晚了
    //p已经销毁，没有变量储存了那块空间的地址
    return 0;
}
//为防止这样的情况发生，一定要成对使用malloc和free
//free(p)
//p=NULL
//或者将p返回，在main函数中有指针接收，这时再释放也可以

void test()
{
    int* p = (int*)malloc(100);
    if (null == p)
    {
        return;
    }
    //使用
    if (1)
        return;
    //释放
    free(p);
    p = null;
    //前面已经return,free可能并没有得到执行
}

int main()
{
    test();
    return 0;
}

切记：动态开辟的空间一定要释放，并且正确释放