动态内存分配（3）——柔性数组

最新推荐文章于 2025-04-26 23:14:21 发布

从前慢，现在也慢

最新推荐文章于 2025-04-26 23:14:21 发布

阅读量485

点赞数 5

CC 4.0 BY-SA版权

分类专栏： C语言进阶文章标签：柔性数组数据结构 c语言

本文链接：https://blog.youkuaiyun.com/wangjiushun/article/details/131750308

C语言进阶专栏收录该内容

11 篇文章

订阅专栏

文章介绍了C99标准引入的柔性数组特性，它允许在结构体的末尾声明未知大小的数组。柔性数组需要在运行时通过动态分配内存来确定大小，其优势在于简化内存管理和提高访问速度。文章通过代码示例展示了如何声明、使用和动态扩展柔性数组，并对比了不使用柔性数组时的内存管理方式，强调了其在内存释放和连续内存访问上的优点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言：

以前我们所学数组（包括变长数组），在数组声明的时候，就必须指定数组的大小，它所需要的内存在编译时分配。但是有时候需要的数组大小在程序运行的时候才能知道，该怎么办呢？这就是我们今天要来学习的新内容——柔性数组。

一、柔性数组的介绍

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

示例：

typedef struct st_type
{
	int i;
	int a[0];//表示数组的大小是未知的——柔性数组成员
}type_a;

有些编译器会报错无法编译可以改成将a[0]改为a[]：

typedef struct st_type
{
	int i;
	int a[];//表示数组的大小是未知的——柔性数组成员
}type_a;

注意：

1、柔性数组是C99中引入的，支持C99柔性数组的编译器才可使用柔性数组（VS集成开发支持）。

2、柔性数组成员必须是结构体的成员，还必须是结构中的最后一个成员。

3、柔性数组成员在声明的时候数组大小不写和数组大小为0是一样的（arr[]和arr[0]）,表示数组的大小是未知的。

二、柔性数组的特点

特点：

1、结构中的柔性数组成员前面必须至少有一个其他成员(我们想分配一个不定长的数组，所以定义一个结构体，最少有两个成员。一个代表数组的长度，一个是柔性数组成员)。

2、sizeof返回的这种结构大小不包括柔性数组的内存（零长度的数组存在于结构体中，但是不占结构体的大小，可理解为一个没有内容的占位标识，直到我们给结构体分配了内存，这个占位标识才变成一个有长度的数组）。

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

讲解：

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

代码演示：


typedef struct st_type
{
	int i;//必须至少有一个其他成员——数组长度
	int a[];//表示数组的大小是未知的——柔性数组成员
}type_a;

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

代码演示：

#include<stdio.h>

typedef struct S
{
	int i;//必须至少有一个其他成员
	int a[];//表示数组的大小是未知的——柔性数组成员
}S;

int main()
{
	//计算结构体的大小并将其打印
	printf("%d\n", sizeof(S));
	return 0;
}

运算结果：

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

代码演示：

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

typedef struct S
{
	int i;//必须至少有一个其他成员
	int a[];//表示数组的大小是未知的——柔性数组成员
}S;

int main()
{
	//使用柔性数组成员的结构，使用malloc进行内存分配，
	//并且分配的内存应该大于结构的大小。
	//给柔性数组开辟10个整形的空间
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	return 0;
}

图示：

三、柔性数组的使用

代码演示1：使用柔性数组——结构体中数据是连续的


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

typedef struct S
{
	int i;//必须至少有一个其他成员
	int a[];//表示数组的大小是未知的——柔性数组成员
}S;

int main()
{
	//给柔性数组成员开辟10个整形的空间
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	//判断是否开辟成功
	if (NULL == ps)
	{
		//打印错误信息
		perror("malloc");
		return 1;
	}
	//使用
	ps->i = 10;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
		printf("%d ", ps->a[i]);
	}
	//增容，在添加10个整形
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
        ps-> i = 20;
	}
	else
	{
		perror("realloc");
		//增容失败，释放之前开辟的
		free(ps);
		ps = NULL;
		return 1;
	}
	//再次使用（略）
	//释放增容成功
	free(ps);
	ps = NULL;
	return 0;
}

四、柔性数组的优势

代码演示2：不使用柔性数组——结构体中的数据不连续


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

typedef struct S
{
	int i;
	int* a;//不使用int a[]柔性数组，使用指针
}S;

int main()
{
	//给结构S开辟空间
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	//判断是否开辟成功
	if (NULL == ps)
	{
		//打印错误信息
		perror("malloc");
		return 1;
	}
	//使用
	ps->i = 10;
	ps->a = (int*)malloc(10 * sizeof(int));
	if (NULL == ps->a)
	{
		//打印错误信息
		perror("malloc->a");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
		printf("%d ", ps->a[i]);
	}
	//增容，在添加10个整形
	int* ptr = (int*)realloc(ps->a, 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps->a = ptr;
        ps->i = 20;
	}
	else
	{
		perror("realloc->ptr");
		//增容失败，先释放结构体指针a指向的之前开辟的空间
		//（因为先释放结构体的空间，就找不着a指向的空间了）
		free(ps->a);
		ps->a = NULL;
		//再释放结构体的空间
		free(ps);
		ps = NULL;
		return 1;
	}
	//再次使用（略）
	//释放增容成功
	//先释放结构体指针a指向的之前开辟的空间
	//（因为先释放结构体的空间，就找不着a指向的空间了）
	free(ps->a);
	ps->a = NULL;
	//再释放结构体的空间
	free(ps);
	ps = NULL;
	return 0;
}

上面代码演示1和代码演示2都可以完成同样的功能，谁更好呢？

答案是：代码演示1，他有两个好处。

好处1：方便内存释放

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

图示：