realloc的补充 柔性数组

🐶博主主页：@ᰔᩚ. 一怀明月ꦿ 

❤️‍🔥专栏系列：线性代数，C初学者入门训练，题解C，C的使用文章，「初学」C++

🔥座右铭：“不要等到什么都没有了，才下定决心去做”

🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀

目录

🐰内存分布

 🐰realloc

🐰柔性数组（柔性数组又名0长度数组）

---

🐰内存分布

内核空间	（用户不能读写）
栈区	函数的形参以及局部变量
内存映射段	（文件映射，动态库，匿名映射）
堆区	动态开辟的内存（malloc，calloc，realloc）
静态区	全局变量 静态变量
代码段	（可执行代码/只读常量）存放函数体的二进制代码

 🐰realloc

realloc用于原空间不足继续开辟更大的空间，引用头文件为#include<stdlib.h>
realloc的原型：

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

void* ptr：原空间的首地址
size_t size：开辟新空间的大小
 

注：如果ptr为空指针时，则他的作用和malloc相同，例如：

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int *ptr=(int *)realloc(NULL,20);
    //这里就相当于malloc开辟了20个字节，例如
    //int* ptr=(int*)malloc(20);
    for(int i=0;i<5;i++)
    {
        printf("%d ",ptr[i]);
    }
    return 0;
}

🐰柔性数组（柔性数组又名0长度数组）

柔性数组的特点：

（1）结构中的柔性数组成员前面必须至少有一个其他成员。

这样创建的柔性数组是正确的

struct student
{
    int n;
    int arr[];//或者int arr[0]
};

这样创建是绝对不允许的

struct student
{
    int arr[]//如果是柔性数组，前面应该还有其他类型的成员
};

（2）sizeof返回的这种结构大小不包括柔性数组的内存

（3）包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小

 

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
typedef struct student
{
    int n;//0-3
    char c;//4
    //8
    //int arr[0];
    int arr[];//这里没有指定大小，这就是柔性数组
}student;
int main()
{
    //（2）
    printf("%d\n",(int)sizeof(student));//结果是8
    //（3）
    student* ptr=(student*)malloc(sizeof(student)+10*sizeof(int));
    if(ptr==NULL)
    {
        printf("%s\n",strerror(errno));//打印申请失败的原因
        return 1;
    }
    //使用
    ptr->n=100;
    ptr->c='w';
    for(int i=0;i<10;i++)
    {
        ptr->arr[i]=i;
    }
    for(int i=0;i<10;i++)
    {
        printf("%d ",ptr->arr[i]);
    }
    //利用realloc函数调整arr数组的大小
    student* str=(student*)realloc(ptr,sizeof(student)+20*sizeof(int));
    if(str==NULL)
    {
        printf("%s\n",strerror(errno));//打印申请失败的原因
        return 1;
    }
    else
    {
        ptr=str;
    }
    //释放
    free(ptr);
    return 0;
}

结构体指针方案（不使用柔性数组，达到柔性数组的目的）

指针方案一：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
typedef struct class
{
    int n;
    char c;
    int* arr;
}class;
int main()
{
    class* ptr=(class*)malloc(sizeof(class));
    int* str=(int*)malloc(sizeof(int)*10);
    if(str==NULL)
    {
        printf("%s\n",strerror(errno));//如果分配失败，打印错误信息
        return 1;
    }
    else
    {
        ptr->arr=str;
    }
    //用realloc调整arr的大小
    str=(int*)realloc(ptr->arr,20*sizeof(int));
    if(str==NULL)
    {
        printf("%s\n",strerror(errno));
        return 1;
    }
    else
    {
        ptr->arr=str;
    }
    //释放
    free(ptr->arr);
    free(ptr);
}

指针方案二：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
typedef struct class
{
    int n;
    char c;
    int* arr;
}class;
int main()
{
    class ptr;//创建了一个结构体对象
    int* str=(int*)malloc(sizeof(int)*10);
    if(str==NULL)
    {
        printf("%s\n",strerror(errno));
        return 1;
    }
    else
    {
        ptr.arr=str;
    }
    //调整arr的大小
    str=(int*)realloc(ptr.arr,20*sizeof(int));
    if(str==NULL)
    {
        printf("%s\n",strerror(errno));
        return 1;
    }
    else
    {
        ptr.arr=str;
    }
    //释放
    free(ptr.arr);
    return 0;
}

总结：对比两种方法（柔性数组和结构体指针）不难发现柔性数组更加简便，可以整理出柔性数组有两大优势：

（1）动态开辟的内存比较容易释放

使用柔性数组，只需要调用用一次free函数进行释放，而使用结构体指针方案一则需要两次调用free函数进行释放，这样会导致忘记释放了，从而出现内存泄漏的问题，使程序更容易出错。

（2）程序的运行速度更快

柔性数组只动态开辟了一块空间，而结构体指针这种方法开辟两块空间。结构体指针这种方法，内存碎片比较多，程序访问速度有所下降。

 🌸🌸🌸如果大家还有不懂或者建议都可以发在评论区，我们共同探讨，共同学习，共同进步。谢谢大家！ 🌸🌸🌸