一.什么是柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。在C99标准 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

🌝例子

//写法1
struct st_type
{
    int i ;
    int arr[];	//柔性数组成员
};

//写法2
struct st_type
{
    int i ;
    int arr[0];	//柔性数组成员
};

//对于写法2：有些编译器会报错无法编译

二.柔性数组的特点

🛸特点1 :结构中的柔性数组成员前面必须至少一个其他成员。

struct A
{
    int arr[];	//柔性数组成员
    int i;
};
//可能会报错，柔性数组成员前面必须至少一个其他成员

🚅特点2: sizeof 返回的这种结构大小不包括柔性数组的内存。

struct A
{
    int i ;	//4
    int arr[];
};
int main()
{
    printf("%d\n",sizeof(struct A)); //4
    return 0;
}

🚞特点3: 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小

struct st_type
{
    int i ;
    int arr[];
};
int main()
{
    struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type)+10*sizeof(int));
    //为数组arr开辟了10个整形大小的空间
    if( p!= NULL)
    {
        int i = 0;
        for(i = 0;i < 10;i++)
        {
            p->arr[i] = i;
            printf("%d ",p->arr[i]);
        }
        p->i = 100;
        printf("%d\n", p->i);
    }
  	return 0;
}

🎨为数组arr开辟了10个整形大小的空间

三.使用柔性数组的好处

🛍使用柔性数组的例子：

struct st_type
{
    int i;
    int arr[];	//柔性数组成员
};
int main()
{
    struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
    //为数组arr开辟了10个整形大小的空间
    int i = 0;
    if (p != NULL)
    {
        for (i = 0; i < 10; i++)
        {
            //为柔性数组成员赋值
            p->arr[i] = i;
            printf("%d ", p->arr[i]);
        }
        p->i = 100;
        printf("%d\n", p->i);
    }
    else
    {
        printf("开辟失败\n");
        return -1;
    }
    //当空间不够时也可以增容
    struct st_type* ptr = (struct st_type*)realloc(p, sizeof(struct st_type) + 20 * sizeof(int));
    if (ptr == NULL)
    {
        printf("扩容失败\n");
        return -1;
    }
    else
    {
        p = ptr;	//把增容空间的地址赋给p
    }
    //使用
    for (i = 10; i < 20; i++)
    {
        p->arr[i] = i;
        printf("%d ", p->arr[i]);
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}

💎针对上面的，我们也可以使用动态数组实现

struct st_type
{
    int i ;	
    int* arr;//指向动态开辟的数组	
};
int main()
{
    struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type));
    ps-> i = 100;
    ps->arr = (int*)malloc(10*sizeof(int));
    int i = 0;
    for(i = 0;i <10;i++)
    {
        ps->arr[i] = i;
        printf("%d ",ps->arr[i]);
    }
    // a空间不够则增容
    int* ptr = (int*)realloc(ps->arr,20*sizeof(int));
    if(ptr == NULL)
    {
        printf("扩容失败\n");
        return -1;
    }
    else
    {
        ps->arr = ptr;
    }
    //使用
    for(i = 10;i<20;i++)
    {
        ps->arr[i] = i;
        printf("%d ",ps->arr[i]);
    }
    
    //释放！！注意释放顺序
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}

👒注意！！：要先释放结构体内动态开辟的数组，再释放动态开辟的结构体

🤎对于上述的写法1和写法2可以实现相同的功能，但是写法1实现由两个好处

💦💨第一个好处：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

💛第二个好处：有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎片。

四.什么是内存碎片

💓动态分配将不可避免会产生内存碎片的问题，那么什么是内存碎片？内存碎片即“碎片的内存”描述一个系统中所有不可用的空闲内存，这些碎片之所以不能被使用，是因为负责动态分配内存的分配算法使得这些空闲的内存无法使用，这一问题的发生，原因在于这些空闲内存以小且不连续方式出现在不同的位置。因此这个问题的或大或小取决于内存管理算法的实现上。 [摘自百度百科]

💢通俗来说，动态开辟空间是随机开辟的，空间之间的间隙就是内存碎片

💥希望本文章对你有所帮助！欢迎大佬们留个三连支持一下！

关于那些柔性数组的知识

一.什么是柔性数组

二.柔性数组的特点

三.使用柔性数组的好处

四.什么是内存碎片