前言

也许你从来就没有听过柔性数组（flexible array）这个概念，但他是真的存在；
柔性数组的概念存在于C99标准当中，C99标准表示：结构体的最后一个成员可以是一个大小不确定的数组，这个数组就叫做柔性数组;
既然搭配了柔性这一修饰词，那么这个数组就不会是”耿直“的了。

柔性数组的特点

柔性数组的大小是不确定的；
他是存在于结构体当中，并且只能放在结构体的最后一个成员位置；
柔性数组所在位置的前面至少要有一个成员；
当柔性数组存在于一个结构体当中时，计算结构体的大小，不将柔性数组算在内；
柔性数组是未知大小的数组，要使用他，必须要用malloc来为他开辟空间，并且这个空间的大小一定要大于所在结构体的大小，简单来说，这个开辟的空间的大小减去所在的结构体大小剩下的空间就是这个柔性数组可以使用的了。

柔性数组的定义：

1.
struct s
{
	char a;
	int a[];  // [] 里不放数据
};
// 当然也可以
2.
struct s
{
	int a;
	char b[0]; // 上面的定义在有些编译器上可能会报错，这样也是可以的
};

上述1中的int a[],2中的char b[0],就是所谓的柔性数组。

柔性数组的大小是不确定，下面来测试一下结构体的大小：

#include <stdio.h>
//1.
struct s1
{
	char a;
	char b;
	int c;
	int d[];  // [] 里不放数据
};
// 当然也可以
//2.
struct s2
{
	int a;
	int b;
	int c;
	char d[0]; // 上面的定义在有些编译器上可能会报错，这样也是可以的
};

int main()
{
	printf("%d\n", (int)sizeof(struct s1));
	printf("%d\n", (int)sizeof(struct s2));

	return 0;
}

运行结果：

在这里插入图片描述
如果我们不看最后一个柔性数组成员，计算出来的结构体大小恰好是上面的结果，所以，当结构体里面含有柔性数组成员的时候，计算结构体大小时，是不会将柔性数组的大小计算在内的。

柔性数组的使用

有了上面对柔性数组的认识，那么柔性数组是如何使用的呢？

上面说了要用malloc来为此开辟空间，并且开辟的空间的大小要大于所在结构体的大小。

例子：

#include <stdio.h>
#include <stdlib.h>

struct s
{
	char a;
	int b[]; // 柔性数组
}* s; // 创建结构体指针变量

int main()
{                                 // 这里是结构体的空间 //这是柔性数组的空间：十个整型
	struct s* tmp = (struct s*)malloc(sizeof(struct s) + 40);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	s = tmp;
	
	// 给柔性数组赋值
	for (int i = 0; i < 10; i++)
	{
		s->b[i] = i + 1;
	}

	// 打印柔性数组的内容
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", s->b[i]);
	}

	// 记得释放空间
	free(s);

	return 0;
}

在这里插入图片描述
运行结果：

在这里插入图片描述

当然，如果需要给柔性数组扩容，可以用realloc进行以下操作(核心代码)：

                                           // 将柔性数组的空间增大到可以存储15个整型
	struct s* cur = (struct s*)realloc(s, sizeof(struct s) + 60);
	if (cur == NULL)
	{
		perror("realloc fail");
		exit(-1);
	}
	s = cur;

	// 给扩容的空间赋值
	for (int i = 10; i < 15; ++i)
	{
		s->b[i] = i + 1;
	}

	// 打印柔性数组扩容后的内容
	for (int i = 0; i < 15; i++)
	{
		printf("%d ", s->b[i]);
	}

运行结果：

在这里插入图片描述

据此，柔性数组的使用掌握这些已经够用了，可以看到，柔性数组是可以随意更改数组大小的，“柔性”体现的淋漓尽致，不过一定要注意内存泄漏的问题。

柔性数组的优势

学会了柔性数组的使用，实际上，上面实现的柔性数组的功能还可以这样设计：

#include <stdio.h>
#include <stdlib.h>

typedef struct s
{
	char b;
	int* a;
}s; // typedef 重命名

int main()
{
	s* stru;  // 指向类型为s的结构体指针
	s* tmp1 = (s*)malloc(sizeof(s));
	if (tmp1 == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	stru = tmp1;  // 将开辟的结构体空间给给stru
	stru->b = 'a';
	                // 开辟可以存放十个整型的空间
	int* tmp2 = (int*)malloc(sizeof(int) * 10);
	if (tmp2 == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	stru->a = tmp2; // 将开辟的可以存放十个整型的空间给给stru指向的结构体里的整型指针

	// 给a指向的空间赋值
	for (int i = 0; i < 10; i++)
	{
		stru->a[i] = i + 1;
	}

	// 打印a指向的空间里的内容
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", stru->a[i]);
	}

	// 别忘记释放噢,这里开辟了两次就要释放两次，并且要有里到外依次释放
	free(stru->a);
	stru->a = NULL;
	free(stru);
	stru = NULL;

	return 0;
}

柔性数组的使用那个设计放法与这个设计方法实现的效果是一样的，但是柔性数组的那个设计有两个好处：

方便内存释放：
可以看到第二个设计释放了两次，如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
这样有利于访问速度：
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，也没有高多少，反正你跑不了要用做偏移量的加法来寻址）