高阶C语言补充：柔性数组

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

vs编译器也支持柔性数组。

之所以把柔性数组单独列出，是因为：

1、柔性数组是建立在结构体的基础上的。

2、柔性数组的使用用到了动态内存分配。

这使得柔性数组不能单独的放在其他两篇文章当中，因此本文较为剪短，只介绍柔性数组这一个概念。

柔性数组的声明：

1、一定是在结构体中。

2、柔性数组前面一定要有其他成员。

cpp 复制代码

typedef struct s
{
	int i;
	int a[0];//柔性数组成员
}type_a;

//若编译器其无法通过，则可以写为：
typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

柔性数组的特点：

1、结构体中的柔性数组成员前必须至少有一个其他成员。

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

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

cpp 复制代码

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

//柔性数组成员和int*型成员类似
struct S
{
	int n;
	int* arr;
};

异：

1、柔性数组只需要一次malloc就可以完成结构体成员和数组的创建。

2、int*成员需要两次malloc来开辟，两次free来释放。

同：

1、柔性数组和int*成员两个都需要malloc来开辟空间、free释放。

柔性数组的使用

cpp 复制代码

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
	if (ps == NULL)
	{
		return 1;
	}
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	//调整大小
	struct S* ptr = (struct S*)realloc(ptr, sizeof(struct S) + 80);
	if (ptr != NULL)
	{
		ps = ptr;
		ptr = NULL;
	}

	//释放
	free(ps);//只需要一次释放
	ps = NULL;
	return 0;
}

int*成员的使用

cpp 复制代码

int main()
{
	//创建
	struct S* ps = (struct S*)malloc(sizeof(struct S));//第一次malloc
	if (ps == NULL)
	{
		//...
		return 1;
	}
	ps->n = 100;
	ps->arr = (int*)malloc(40);//第二次malloc
	if (ps->arr == NULL)
	{
		//..报错
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	//扩容
	int* ptr = (int*)realloc(ps->arr, 80);
	if (ptr == NULL)
	{
		return 1;
	}
	ps->arr = ptr;
	ptr = NULL;

	//释放
	//两次释放
	free(ps->arr);
	free(ps);
	return 0;
}

1、malloc的次数越多，free的次数越多，越容易造成内存泄漏。

2、malloc的次数越多，造成的内存碎片就越多，程序的性能就越低。

柔性数组的优势

方便内存的释放。
连续的内存能提高访问速度

柔性数组只需要释放一次，不易产生内存泄漏。malloc一次开辟的空间是连续的，对内存的访问速度更高。

一个结构体中只允许存在一个柔性数组。