【C语言】柔性数组（可变长数组）

一、介绍

柔性数组 （Flexible Array），又称可变长数组 。一般数组的长度是在编译时确定，而柔性数组对象的长度在运行时确定。在定义结构体时允许创建一个空数组 （例如：arr [ 0 ] ），该数组的大小可在程序运行过程中按照你的需求变动。

struct S
{
    int n;
    int arr[0]; // 柔性数组成员
};

// 有些编译器会报错无法编译可以改成：

struct S
{
    int n;
    int arr[]; // 柔性数组成员
};

柔性数组 （Flexible Array），是在C语言的 C99 标准中，引入的新特性。结构中的最后一个元素的大小允许是未知的数组，即为柔性数组。

---

二、柔性数组的特点

1. 结构中的柔性数组成员前面必须至少一个其他成员。
2. sizeof 返回的这种结构大小不包括 柔性数组的内存。
3. 包含柔性数组成员的结构用 malloc () 函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

#include <stdio.h>

struct S
{
    int n; //4
    int arr[0]; //大小是未知的
}s;

int main()

{
    printf("%d\n", sizeof(s)); //4
 
    struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int)); 
    // 后面+的大小就是给柔性数组准备的

    return 0;
}

因为这段空间是 malloc 出来的，所以后面 arr 的空间如果不够可以进行调整。它的大小是可以改变的，这里就体现出了 "柔性" 的意义。

---

三、柔性数组的使用

// 代码一
#include <stdio.h>
#include <stdlib.h>
 
struct S
{
    int n;
    int arr[0];
};
 
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int));
    ps->n = 10;

    for (int i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }

    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20*sizeof(int));
    if (ptr != NULL)
    {
        ps = ptr;
    }

    free(ps);
    ps = NULL;
 
    return 0;
}

这样柔性数组成员 arr ，相当于获得了 10 个整型元素的连续空间。

---

四、柔性数组的优势

// 代码二
#include <stdio.h>
#include <stdlib.h>
 
struct S
{
    int n;
    int* arr;
};
 
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if (ps == NULL)
    {
        return 1;
    }
    ps->n = 10;
    ps->arr = (int*)malloc(10 * sizeof(int));

    if (ps->arr == NULL)
    {
        return 1;
    }
    for (int i = 0; i < 10; i++)
    {
        ps->arr[i];
    }
 
    int* ptr = (struct S*)realloc(ps->arr, 20 * sizeof(int));
    if (ptr != NULL)
    {
        ps->arr = ptr;
    }
 
    // 这里需要回收2个空间，且回收必须有先后
    free(ps->arr); // 先free第二块空间
    ps->arr = NULL;
    free(ps);
    ps = NULL;
 
    return 0;
}

上述 代码一 和 代码二 可以完成同样的功能，但是代码一 的实现有两个好处：

• **第一个好处是：**方便内存释放。

虽然 代码二 实现了相应的功能，但是和 代码一 相比还是有很多不足之处的。 代码二 使用指针完成， 进行了两次 malloc ，而两次 malloc 对应了两次 free ，相比于 代码一更容易出错。
如果我们的代码是在一个给别人用的函数中，你在里面做了两次内存分配，并把整个结构体返回给用户。虽然用户调用 free 可以释放结构体，但是用户并不知道这个结构体内的成员也需要 free ，所以你不能指望用户来发现这件事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好（而不是多次分配），并且返回给用户一个结构体指针， 用户只需使用一次 free 就可以把所有的内存都给释放掉，可以间接地减少内存泄露的可能性。

• **第二个好处是：**这样有利于访问速度。

连续内存多多少少有益于提高访问速度，还能减少内存碎片。malloc 的次数越多，产生的内存碎片就越多，这些内存碎片不大不小，再次被利用的可能性很低。内存碎片越多，内存的利用率就会降低。频繁的开辟空间效率会变低，碎片也会增加。