struct S
{
	int i;
	char ch[0];//char ch[]
};
int main()
{

	return 0;
}

柔性数组的特点：

一 结构中的柔性数组成员前面必须至少一个其他成员。结构体成员中不能就会只有一名柔性数组成员，应该还包含其他的非柔性数组的成员。

struct s
{
	int arr[];
};

二、sizeof返回的这种结构大小不包括柔性数组的内存
所以，当你用sizeof来计算一个含有柔性数组成员的结构体大小时，计算出的结果不包括柔性数组成员在内。
比如：

struct S
{
	int i;
	char ch[0];//char ch[]
};
int main()
{
	printf("%zd\n", sizeof(struct S));//结果是4
	return 0;
}

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

struct S
{
	int i;
	char ch[0];//char ch[]
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(char));
	if (ps == NULL)//判断
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(ps->ch) = 'Q';
	}
	for (i = 0; i < 10; i++)
	{
		printf("%c ", *(ps->ch));
	}
	free(ps);
	ps = NULL;
	return 0;
}

在图中开辟的前面的sizeof开辟的是int i的空间，后面一个是柔性数组的空间。然后我们可以开辟的10个空间打印10个字符Q。

模拟实现柔性数组的功能
其实，我们若不借用柔性数组也能实现以上功能：

typedef struct S
{
	int i;
	char* ch;
}S;
int main()
{
	S* ps = (S*)malloc(sizeof(S));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->ch = (char*)malloc(sizeof(char) * 10);
		if (ps->ch == NULL)
		{
			perror("malloc");
			return 1;
		}
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(ps->ch) = 'Q';
		}
		char* plc = (char*)realloc(ps->ch, 20 * sizeof(char));
		if (plc != NULL)
		{
			ps->ch = plc;
		}
		else
		{
			perror("realloc");
			return 1;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%c ", *(ps->ch));
		}
		free(ps->ch);
		ps->ch = NULL;
		free(ps);
		ps = NULL;
	return 0;
}

柔性数组其实也就是结构体中的一个数组，准确来说，是一个空间大小可以自由变换的数组，那么我们在结构体中定义一个指针，使指针指向的空间可以自由变换（即指针指向的是动态开辟的内存），也就达到了这个效果。

注意： 这里释放动态内存空间时，需要先释放ps->ch指向的动态内存空间，再释放ps指向的动态内存空间。 如果我们先释放的是ps指向的动态内存空间，那么ps->ch所指向的空间就再也找不到了。

柔性数组的优点：