什么是柔性数组以及柔性数组的用法和特点

C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1. 栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区：一般由程序员分配释放，若程序员不释放，程序结束时可能由操作系统回收。分配方式类似于链表。
3. 数据段（静态区）：存放全局变量、静态数据、程序结束后由系统释放
4. 代码块：存放函数体（类成员函数和全局函数）的二进制代码

---

 

可能大家没有听说所柔性数组，柔性数组这个东西比较不常见，今天我们就来一起看一下什么是柔性数组以及柔性数组的用法和特点。

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

struct st_type

{

     int i;

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

}；

也可以写成这样：

struct st_type

{

     int i;

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

}；

柔性数组的特点

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

柔性数组
struct S
{
	int n;
	char c;
	//int arr[];//柔性数组,两个都可以使用
	int arr[0];//柔性数组
};

int main()
{
	//求结构体的大小
	printf("%d\n", sizeof(struct S));//8个字节
	return 0;
}

柔性数组的使用（方案一）

柔性数组的使用
struct S
{
	int n;
	char c;
	//int arr[];//柔性数组,两个都可以使用
	int arr[0];//柔性数组
};

int main()
{
	//创建
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (NULL == ps)
	{
		printf("malloc:%s", strerror(errno));
		exit(-1);
	}

	//使用
	ps->n = 100;
	ps->c = 'w';
	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	struct S* str = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (NULL == str)
	{
		printf("realloc:%s", strerror(errno));
		exit(-1);
	}
	else
	{
		ps = str;
		for (int i = 10; i < 20; i++)
		{
			ps->arr[i] = i;
		}
		for (int i = 10; i < 20; i++)
		{
			printf("%d ", ps->arr[i]);
		}
	}
	printf("\n");

	//释放
	free(ps);
	ps = NULL;

	//求结构体的大小
	printf("%d\n", sizeof(struct S));
	return 0;
}

结构体中用指针指向malloc开辟出的空间的使用（方案二）

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

int main()
{
	//创建
	struct S* tmp = (struct S*)malloc(sizeof(struct S));
	if (NULL == tmp)
	{
		printf("malloc:%s", strerror(errno));
		exit(-1);
	}
	int* str = (int*)malloc(sizeof(int) * 10);
	if (NULL == str)
	{
		printf("malloc:%s", strerror(errno));
		exit(-1);
	}
	else
	{
		tmp->arr = str;
		for (int i = 0; i < 10; i++)
		{
			tmp->arr[i] = i;
		}
		for (int i = 0; i < 10; i++)
		{
			printf("%d ", tmp->arr[i]);
		}
	}
	str = (int*)realloc(tmp->arr, sizeof(int) * 20);
	if (NULL == str)
	{
		printf("realloc:%s", strerror(errno));
		exit(-1);
	}
	else
	{
		tmp->arr = str;
		for (int i = 10; i < 20; i++)
		{
			tmp->arr[i] = i;
		}
		for (int i = 10; i < 20; i++)
		{
			printf("%d ", tmp->arr[i]);
		}
	}
	//释放
	free(tmp->arr);
	tmp->arr = NULL;
	free(tmp);
	tmp = NULL;
	return 0;
}

柔性数组的优势

上述方案一和方案二可以完成相同的功能，但是方案一的实现有两个好处：

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

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

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

连续的内存有益于提高访问速度，也有益于减少内存碎片。