动态内存管理函数详解

一、为什么要有动态内存分配

比如我们要存班级学生的数学成绩

如果用int  arr[10] = { 0 }；空间就固定了，只能存10个人的成绩，无法调整大小，班级有三十个人的话就存放不下。

因此C语言引入了动态内存开辟，可以申请和释放空间，使用灵活。

二、动态内存管理的四个函数

malloc

1.使用规则

malloc（memory allocated）是动态内存开辟的函数，包含的头文件是stdlib.h

用法:    void* malloc (size_t size);

size_t size 代表向内存申请多少个字节空间

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

int main()
{
    void* p = malloc(40);
    return 0;
}

malloc只知道申请多大的空间，但不知道会放什么类型数据，所以malloc函数只能返回void*。

如果程序猿想申请十个整型的空间，即四十个字节，就要强制类型转化成int*类型，这样p+1就能找到下一个整型数据。

int main()
{
    int* p = (int*) malloc(40);
    return 0;
}

2.开辟结果

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

如果开辟失败（可能开的空间太大了），则返回一个NULL指针，因此malloc的返回值一定要做检查。

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*) malloc(40);
    if(p == NULL)
    {
        perror("malloc");
        return 1;\\异常返回，用1来进行区分
    } 
        
    return 0;
}

3.例子

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*) malloc(40);
    if(p == NULL)
    {
        perror("malloc");
        return 1;\\异常返回，用1来进行区分
    } 

    int i=0;
    //赋值
    for(i=0; i<10; i++)
    {
       // *p=i;
       //p++;//p走远了，没有记录起始地址，找不到起始位置，写法存在危险

        *(p+i) = i;//p起始位置没有改变
    }
    //打印
       for(i=0; i<10; i++)
    {
        printf("%d ",*(p+i));
    }

     return 0;
}

4.申请空间区域

malloc申请空间是在堆区中（malloc,  calloc,  realloc,  free都是)。

free

1.使用规则

作用：free是专门用来做动态内存的释放和回收的（声明也是在stdlib.h中）

void free (void* ptr);

void* ptr传的是起始地址

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

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

2.例子

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*) malloc(40);
    if(p == NULL)
    {
        perror("malloc");
        return 1;\\异常返回，用1来进行区分
    } 

    int i=0;
    //赋值
    for(i=0; i<10; i++)
    {
       // *p=i;
       //p++;//p走远了，没有记录起始地址，找不到起始位置，写法存在危险

        *(p+i) = i;//p起始位置没有改变
    }
    //打印
       for(i=0; i<10; i++)
    {
        printf("%d ",*(p+i));
    }
   
     free(p);

     return 0;
}

3.存在问题

释放完，p指向的空间还给了操作系统，但是p里放的地址还是起始空间的地址，为了避免p成为野指针，所以最后会把p置为空指针。

 free(p);
 p = NULL;

calloc

1.使用方法

calloc也用来动态内存分配，与malloc相似，但不完全相同。

void* calloc (size_t num, size_t size);

函数功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。

与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。

2.举例

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*) calloc(10, sizeof(int));
    if(p == NULL)
    {
        perror("calloc");
        return 1;
    } 

    int i=0;
    //打印
       for(i=0; i<10; i++)
    {
        printf("%d ",*(p+i));
    }
       
     free(p);
     p=NULL;
     return 0;
}

运行结果如下：

realloc

1.使用规则

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

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

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

ptr 是要调整的内存地址

size 是调整之后新的空间大小

返回值为调整之后的内存起始位置。

注意：realloc不会初始化空间

2.举例

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*) calloc(10, sizeof(int));
    if(p == NULL)
    {
        perror("calloc");
        return 1;
    } 

    int i=0;
    //打印
       for(i=0; i<10; i++)
    {
        printf("%d ",*(p+i));
    }

     //空间不够，想要扩大空间，20个整型
     int* ptr=(int*)realloc(p,20*sizeof(int));//返回值不敢用p来接收，因为如果调整失败，p原来的40个字节也找不到
      if(ptr != NULL)//判断不是空指针
    {
        p=ptr;
    } 
    else
    {
        perror("realloc");
        return 1;
    }
    //可以使用空间了
    //释放空间
     free(p);
     p=NULL;
     return 0;
}

3.调整结果

调整空间失败会返回空指针

调整成功会存在两种情况：

情况1：原有空间之后有足够大的空间直接进行扩大，扩大空间后，直接返回旧的空间的起始地址。

ptr仍使用旧空间：

情况2：原有空间之后没有足够大的空间直接进行空间扩大（可能会占用别的数据空间），在这种情况下，realloc函数会在内存的堆区重新找一块空间（满足新的空间的大小需求），同时会把旧的数据拷贝到新的空间，然后释放旧的空间，同时返回新的空间的起始地址。

ptr找新空间：

4.用realloc开辟空间

该函数除了能够调整空间外，还能实现和malloc一样的功能

#include<stdio.h>
#include<stdlib.h>
int main()
{
     int* p = (int*)realloc (NULL, 40);
     //等价于malloc，开辟空间
     free(p);
     p=NULL;
     return 0;
}