动态内存分配---柔性数组

柔性数组

柔性数组指的是结构体类型变量，最后一个元素是数组的话，此数组大小是可以变化的
测试代码

struct Stu {
	int n;
	int arr[0];//未知大小，素组大小可以调整
};
//第二种写法
//struct Stu {
//	int n;
//	int arr[];//未知大小，素组大小可以调整
//};
int main() {

	struct Stu s;
	printf("%d\n", sizeof(s));
	getchar();
	return 0;
}

输出结果是四个字节，说明此结构体没有包含柔性数组大小
注意

struct Stu {
	int n;
	int arr[10];
};

此结构体大小为44个字节。

柔性数组的使用

struct Stu {
	int n;
	int arr[];
};

int main() {
	struct Stu* ps = (struct Stu*)malloc(sizeof(struct Stu) + 5 * sizeof(int));
	return 0;
}

开辟一块连续的空间，ps指向这块空间，前4个字节给n,后面20个字节给柔性数组arr。
使用案例

struct Stu {
	int n;
	int arr[];
};

int main() {

	struct Stu* ps = (struct Stu*)malloc(sizeof(struct Stu) + 5 * sizeof(int));
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 5; i++) {
		ps->arr[i] = i;
	}
	struct Stu* ptr = realloc(ps, 44);
	if (ptr != NULL) {
		ps = ptr;
	}
	for (i = 5; i < 10; i++) {
		ps->arr[i] = i;
	}

	for (i = 0; i < 10; i++) {
		printf("%d\n", ps->arr[i]);
	}
	//释放内存
	free(ps);
	ps = NULL;
	getchar();
	return 0;
}

第二种实现方法

struct Stu {
	int n;
	int* arr;
};

int main() {

	struct Stu* ps = (struct Stu*)malloc(sizeof(struct Stu));
	ps->n = 100;
	ps->arr = malloc(5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 5; i++) {
		ps->arr[i] = i;
	}
	int* ptr = realloc(ps->arr, 10*sizeof(int));
	if (ptr != NULL) {
		ps->arr = ptr;
	}
	for (i = 5; i < 10; i++) {
		ps->arr[i] = i;
	}

	for (i = 0; i < 10; i++) {
		printf("%d\n", ps->arr[i]);
	}
	//释放内存
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	getchar();
	return 0;
}

使用结构体中的arr指针开辟空间，首先

struct Stu* ps = (struct Stu*)malloc(sizeof(struct Stu));

用ps指向开辟的8个字节空间，n占四个字节，arr指针占四个字节
然后通过arr指针开辟20字节空间

ps->arr = malloc(5 * sizeof(int));

由于arr指针是int类型，所以调整大小的时候需要指定为int类型

int* ptr = realloc(ps->arr, 10*sizeof(int));

释放内存的时候要先释放arr所指向的空间，然后释放ps指向的空间

	//释放内存
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

柔性数组的特点

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

柔性数组和第二种方法相比，他的好处主要有

1. 方便内存释放
2. 有利于访问速度，因为他是连续的，也有益于减少内存碎片