柔性数组详解

•  在结构体中

•  最后一个成员

•  未知大小的数组

这就是柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。

C99 中，柔性数组是一种动态可变的数组，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

typedef struct st_type {

   int i; //至少一个其他成员。

   int a[0];//柔性数组成员

}type_a;

有些编译器会报错无法编译，可以改成如下形式：

typedef struct st_type

{

int i;

int a[];//柔性数组成员

}type_a;

一、柔性数组的特点：

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

• sizeof 返回的这种结构大小不包括柔性数组的内存。

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

二、使用sizeof计算包含柔性数组的结构体的大小

其得出的结果不包含柔性数组的内存

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

三、柔性数组的使用

包含柔性数组成员的结构体要用malloc函数来进行内存的动态分配，并且分配的内存应大于结构体的大小，以适应柔性数组的预期大小。这样柔性数组成员a，相当于获得了100个整型元素的连续空间。如下所示：

•int arr[];//定义一个柔性数组

• struct St s = {0};  // 定义并初始化一个St结构体变量s，其中所有成员都被初始化为0。

• struct St* ps = (struct St*)malloc(sizeof(struct St) + 10 * sizeof(int)); // 为ps分配内存

• if (ps == NULL)//防止malloc开辟空间失败，导致内存泄漏
   {
       perror("malloc");
       return 1;
   }

• free(ps);
 ps = NULL;

//先释放数组的内存，然后将结构体的内存也释放掉，并将指针设置为NULL，避免野指针。

• struct St* ptr = (struct St*)realloc(ps, sizeof(struct St) + 15 * sizeof(int));

//使用 realloc 函数将数组的大小从10扩展到15。

代码1:

struct St
{
  char c;
  int n;
  int arr[0];
  //int *arr;
};
int main()
{
  struct St* ps = (struct St*)malloc(sizeof(struct St) + 10 * sizeof(int));
  if (ps == NULL)
  {
    perror("malloc");
    return 1;
  }
  ps->c = 'w';
  ps->n = 100;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  //数组空间不够
  struct St* ptr = (struct St*)realloc(ps, sizeof(struct St) + 15 * sizeof(int));
  if (ptr != NULL)
  {
    ps = ptr;
  }
  else {
    perror("malloc");
    return 1;
  }
  //...继续使用
  for (i = 10; i < 15; i++) {
    ps->arr[i] = i;
  }
  for (i = 10; i < 15; i++) {
    printf("%d ", ps->arr[i]);
  }
  printf("\n%d\n", ps->n);
  printf("%c\n", ps->c);
  //释放
  free(ps);
  ps = NULL;
  return 0;
}

四、用结构体指针代替柔性数组

上述的 type_a 结构也可以设计为下面的结构，也能完成同样的效果。

• int *arr;//一个整型指针，可以用来动态分配数组。

•if (ps == NULL)//防止malloc开辟空间失败，ps为空，导致内存泄漏

   {
       perror("malloc");//报错一
       return 1;
   }

• ps->arr = (int*)malloc(10 * sizeof(int));

if (ps->arr == NULL)//防止malloc开辟空间失败，arr为空，导致内存泄漏

   {
       perror("malloc-2");//报错2
       return 1;
   }

代码2：

struct St
{
  char c;
  int n;
  //int arr[0];
  int *arr;
};
int main()
  {
  struct St s = {0};
  printf("%d\n", sizeof(struct St));
  struct St* ps = (struct St*)malloc(sizeof(struct St));
  if (ps == NULL)
  {
    perror("malloc");
    return 1;
  }
  ps->c = 'w';
  ps->n = 100;
  ps->arr = (int*)malloc(10 * sizeof(int));
  if (ps->arr == NULL)
  {
    perror("malloc-2");
    return 1;
  }
  //使用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  //数组空间不够
  int* ptr = (int*)realloc(ps->arr, 15 * sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  else
  {
    ps->arr = ptr;
  }
  //使用
  for (i = 10; i < 15; i++)
  {
    ps->arr[i] = i;
  }
  for (i = 0; i < 15; i++)
  {
    printf("%d ", ps->arr[i]);
  }
  printf("\n%d\n", ps->n);
  printf("%c\n", ps->c);
  //释放
  free(ps->arr);
  ps->arr = NULL;
  free(ps);
  ps = NULL;
  return 0;
}

五、柔性数组与结构体指针对比

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

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

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

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

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正跑不了要用做偏移量的加法来寻址）

今天就先到这了！！！

看到这里了还不给博主扣个：

⛳️ 点赞☀️收藏 ⭐️ 关注！

你们的点赞就是博主更新最大的动力！

有问题可以评论或者私信呢秒回哦。