动态内存管理（下)

---

前言

对动态内存管理进行补充

1.柔性数组

1.1柔性数组的特点

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

struct S
{
	int a;
	float b;
	int arr[0];
};
int main()
{
	printf("%d", sizeof(struct S));
    return;
}

输出结果为8，显然不包括柔性数组
结构体所占空间大小可以点击看这篇文章

1.2柔性数组的使用

struct S
{
	int a;
	float b;
	int arr[0];
};
int main()
{
	printf("%d", sizeof(struct S));
	struct S* pc = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 4);
	if (pc == NULL)
	{
		return 1;
	}
	pc->a = 10;
	pc->b = 5.5;
	int i = 0;
	for (i = 0; i < 4; i++)//输入数据
	{
		scanf("%d\n", &(pc->arr[i]));
	}
	free(pc);
	pc = NULL;
	return;
}

1.3柔性数组的优势

我们来看完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct S
{
	int a;
	float b;
	int arr[0];
};
int main()
{
	printf("%d", sizeof(struct S));
	struct S* pc = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 4);
	if (pc == NULL)
	{
		return 1;
	}
	pc->a = 10;
	pc->b = 5.5;
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		scanf("%d", &(pc->arr[i]));
	}
	printf("%d %f\n", pc->a, pc->b);
	for ( i = 0; i < 4; i++)
	{
		printf("%d\n", pc->arr[i]);

	}
	//扩容
	struct S* ptr = (struct S*)realloc(pc, sizeof(struct S) + sizeof(int) * 10);
	if (ptr == NULL)
	{
		return 1;
	}
	else
	{
		pc = ptr;
	}
	free(pc);
	pc = NULL;
	return;
}

其实我们发现柔性数组本质不过是最后一个数组大小可变，那么我们就会想到另一种方法实现，我们只需要将将数组改为指针，我们来看代码

struct S
{
	int a;
	float b;
	int *arr;
};
int main()
{
    struct S* pc = (struct S*)malloc(sizeof(struct S));
    //为了保持和上述的方法一致性，所以都在堆上开放
	if (pc == NULL)
	{
		return 1;
	}
	pc->a = 10;
	pc->b = 5.5;
	int* ptr = (int*)malloc(4 * sizeof(int)); 
	if (ptr == NULL)
	{
		return 1;
	}
	else
	{
		pc->arr= ptr;
	}
	int i=0;
	for (i = 0; i < 4; i++)
	{
		scanf("%d", &(pc->arr[i]));
	}
	//malloc(pc->arr,10*sizeof(int));
	printf("%d %f\n", pc->a, pc->b);
	for ( i = 0; i < 4; i++)
	{
		printf("%d\n", pc->arr[i]);

	}
    free(pc->arr);
	pc->arr = NULL;
	free(pc);
	pc = NULL;
	return 0;
}

```
既然我们也有方法实现柔性数组一样的效果那么为什么还要引入这一概念呢，那就不得不谈谈他的优点
第一个好处是：方便内存释放

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

这个好理解
第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

这个我们用画图理解
柔性数组开辟空间

第二种开辟空间

也就是说他是断开的，访问速度相对慢