C语言-动态内存管理

C语言中，我们在使用数组的时候，经常有这样的一个问题：数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。有的时候，我们开辟的空间太小，无法满足我们的需求，有时又太大，浪费空间比较严重。那么能不能按照需求，需要一个就开辟一个空间，需要两个就开辟两个空间？ 这时候就只能试试动态内存开辟了。

一、malloc 函数和free 函数

C语言提供了一个用来动态开辟的函数：malloc函数。头文件是stdlib.h。

void* malloc (size_t size);

该函数能够在内存中申请一块连续可用的空间，如果开辟成功，就返回这个开辟好空间的指针，否则，就返回NULL。因此，在使用malloc的时候，一定要对函数的返回值做检查，避免空指针引用。由于malloc函数不知道要开辟的空间是什么类型，所以在使用的时候，一般要进行强制类型转换。

free 函数是用来进行动态内存的释放和回收的。头文件是stdlib.h。

void free (void* ptr);

free函数只能对动态内存的函数进行释放。如果不是指向的空间不是动态开辟的，那么free函数的结果都是未定义的。

#include<stdio.h>
#include<stdlib.h>
 
int main(void)
{
    int* a = (int*)malloc(sizeof(int));//给a动态开辟空间
    
    free(a);
    a = NULL;
    return 0;
}

 

                             给a申请空间

 

                                 free（a）
 上面的例子只是单纯的说明malloc函数的用法。要注意的是，一般情况下，一定要对malloc函数的返回值做检查，同时，在使用完成malloc函数之后，要及时的进行释放。同时，对引用的指针赋值为空。否则，上面的a就成为了野指针，在后面再次使用的时候就会导致出现非法访问的问题。

二、calloc 函数

calloc 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

void* calloc (size_t num, size_t size);

#include<stdio.h>
#include<stdlib.h>
 
int main(void)
{
    int* p = (int*)calloc(10, sizeof(int));//给p动态开辟空间
 
    free(p);
    return 0;
}

三、realloc 函数

 

有的时候我们使用malloc函数之后，发现申请的空间还是太小，有的时候太大，想要再次进行修改，这个时候就可以使用realloc函数。头文件是stdlib.h。

void* realloc (void* ptr, size_t size);

 ptr 是要调整的内存地址，size 是调整之后新大小。返回值是调整之后的内存的起始位置。

 

realloc函数进行调整的时候，有以下方式：

1，如果原有空间后面有足够大的空间，就直接扩展。

2，另找一块满足要求的空间将原有空间的值进行拷贝，同时返回新的空间地址。

realloc函数的返回结果在使用时也要进行返回值是否为NULL的判断。 

 

 四、常见的内存错误

1，对NULL指针解引用操作

#include<stdio.h>
#include<stdlib.h>
 
void test()
{
    int* p = (int*)malloc(INT_MAX / 4);
    if (p != NULL)
    {
        *p = 20;//如果p的值是NULL，就会有问题,要进行判断
        printf("%d", *p);//20
    }
    else
    {
        printf("为空！");
    }
 
    free(p);
}
 
int main(void)
{
    test();
    return 0;
}
2，对动态开辟的空间越界访问

void test()
{
    int i = 0;
    int* p = (int*)malloc(10 * sizeof(int));
    if (NULL == p)
    {
        exit(EXIT_FAILURE);
    }
    for (i = 0; i <= 10; i++)
    {
        *(p + i) = i;//当i是10的时候越界访问
    }
    free(p);
}
 
 
int main(void)
{
    test();
    return 0;
}
程序就会崩溃。

 

3，对非动态开辟的空间进行free释放

void test()
{
    int a = 10;
    int* p = &a;
    free(p);
}
 
int main(void)
{
    test();
 
    return 0;
}

 

 4，只释放动态开辟内存的一部分

void test()
{
    int* p = (int*)malloc(100);
    p++;
    free(p);//p不再指向动态内存的起始位置
}
 
int main(void)
{
    test();
 
    return 0;
}
结果同上。

5，多次释放同一块内存。

void test()
{
    int* p = (int*)malloc(100);
    free(p);
    free(p);//重复释放
}
 
int main(void)
{
    test();
 
    return 0;
}
还是同样的结果。

6，忘记释放，造成内存泄露。

void test()
{
    int* p = (int*)malloc(100);
    if (NULL != p)
    {
        *p = 20;
    }
}
int main()
{
    test();
    while (1);
}
动态内存的开辟是在堆上开辟的，这里面的内存需要自己手动来进行释放，如果不释放，在最后程序结束的时候可能由系统自动回收。

我们平时写的变量等在栈，数据段（存放全局变量，静态变量）等中，这些不需要手动释放，他们有自己的作用域，出了这个作用域就会自动被销毁。而在堆上开辟的空间需要手动来释放。