在C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员

以下是柔性数组的两种写法：

//写法一：
struct S
{
	int n;
	char c;
	char arr[];//数组大小没有写说明它的大小是未知的 - - 柔性数组成员
};

//写法二：
struct S
{
	int n;
	char c;
	char arr[0];//0也说明它的大小是未知的 - - 柔性数组成员
};

一：柔性数组的特点

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

//利用malloc进行空间分配
struct S
{
	int n;
	char arr[];//数组大小没有写说明它的大小是未知的 - - 柔性数组成员
};

int main()
{
	printf("%d\n", sizeof(struct S));
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(char));//后面的10 * sizeof(char)就是为arr数组开辟的
	return 0;
}

二：柔性数组的使用

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

struct S
{
	int n;
	char arr[];//数组大小没有写说明它的大小是未知的 - - 柔性数组成员
};

int main()
{
	printf("%d\n", sizeof(struct S));
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(char));//后面的10 * sizeof(char)就是为arr数组开辟的
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = 'a';
	}
	for (i = 0; i < 10; i++)
	{
		printf("%c ", ps->arr[i]);
	}
	//增容
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(char));
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps = ptr;
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

三：模拟实现柔性数组

struct S
{
	int n;
	char* arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	//为arr开辟指向的空间
	ps->arr = (char*)malloc(sizeof(char) * 10);//开辟10个字符型的空间
	if (ps->arr == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = 'a';
	}
	for (i = 0; i < 10; i++)
	{
		printf("%c ", ps->arr[i]);
	}
	//增容
	char* ptr = (char*)realloc(ps->arr, sizeof(char) * 20);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps->arr = ptr;
	}
	//使用
	for (i = 0; i < 20; i++)
	{
		*((ps->arr)+i) = 'b';
	}
	for (i = 0; i < 20; i++)
	{
		printf("%c ", *((ps->arr) + i));
	}
	//释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

 常规的柔性数组，只需要malloc一次，free一次，并且空间是连续的，而模拟实现的柔性数组需要malloc两次，free两次，并且空间可能不连续。malloc的次数越多，越容易出错，可能出现忘记释放导致内存泄漏问题。此外，malloc的次数越多，产生的内存碎片就越多，内存利用率就会下降，造成内存空间浪费，malloc次数越少，产生的北村碎片就越少，内存利用率就会增加，会避免内存空间浪费。并且空间连续的情况下，访问数据的时候效率就会更高。

 今天的分享到这里就结束啦！如果觉得文章还不错的话，记得三连支持一下小恐龙，您的支持就是小恐龙前进的动力！