c语言分层理解（内存开辟+柔性数组）

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

我们在使用数组，动态内存管理，以及其他的一些局部变量和全局变量，这些都是我们经常看到的。在我开始学习static关键字的时候，我就在想为什么局部变量使用static就可以变长声明周期呢？不应该是局部变量出来函数就销毁空间吗，这个时候就有了内存空间的概念，下面我们来看看变量在内存中的布局：

通过这张图，我们大致就了解了c/c++程序内存分配的几个区域：

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

这样我们就对内存大概的有个丰富了解，但是这是不完全的，后期会更加细分我们的内存空间。

2. 柔性数组

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

2.1 初步了解写法

方式一：

struct flexible_arr
{
	int i;
	int arr[0];//柔性数组成员 
};
1
2
3
4
5

方式二：

struct flexible_arr
{
	int i;
	int arr[];//柔性数组成员
};
1
2
3
4
5

这两种写法在不同的编译器下有可能会出错，出错就换另外一种写法即可。

2.2 柔性数组的特点

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

2.3 验证结构体不包括柔性数组的内存

解释：这个结构体本身就计算了a变量的大小，并没为柔性数组开辟内存空间。

2.4 柔性数组的使用

直接上代码，更加直观,使用柔性数组：

#include 
#include 
#define ARR_SIZE 4
#define RESIZE 10
struct flexible_arr
{
	int a;
	double d;
	int arr[0];
};

int main()
{
	//必须用动态内存管理库函数对其内存空间开辟，因为结构体并没有为柔性数组开辟空间
	struct flexible_arr* ps = malloc(sizeof(struct flexible_arr) + sizeof(int) * ARR_SIZE);
	//保证指针有效性
	if (ps == NULL)
	{
		return 1;
	}
	ps->a = 10;
	ps->d = 5.0;
	//输入数组中的值
	int i = 0;
	printf("请输入你想输入的四个数字:>\n");
	for (i = 0; i < ARR_SIZE; i++)
	{
		scanf("%d", &ps->arr[i]);
	}
	//打印
	printf("调整前数字:>\n");
	printf("ps->a = %d\n", ps->a);
	printf("ps->d = %lf\n", ps->d);
	for (i = 0; i < ARR_SIZE; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
	//对数组空间进行调整
	struct flexible_arr* ptr = realloc(ps, sizeof(struct flexible_arr) + sizeof(int) * RESIZE);
	if (ptr == NULL)
	{
		return 1;
	}
	else
	{
		ps = ptr;
	}
	//输入
	printf("请输入调整的六个数字:>\n");
	for (i = ARR_SIZE; i < RESIZE; i++)
	{
		scanf("%d", &ps->arr[i]);
	}
	printf("调整后的数字:>\n");
	for (i = 0; i < RESIZE; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	free(ps);
	ps = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

运行展示：

这里只是展示了调整后的数组的内容，并没有调整后对结构体其他成员进行改动。

这里我们使用了柔性数组，来扩展结构体的大小，实际上我们发现，动态内存开辟空间是拿到这个柔性数组成员的地址对其开辟空间，所以拿到的是个地址，这么说我们就可以直接不用柔性数组，直接使用指针来对其内存动态管理分配不就可以了吗？
使用指针实现：

#define P_SIZE 4
#define RESIZE 10
#include 
#include 
struct imitation
{
	int a;
	double d;
	int* ptr;
};

int main()
{
	//申请整个结构体空间
	struct imitation* ps = (struct imitation*)malloc(sizeof(struct imitation));
	if (ps == NULL)
	{
		return 1;
	}
	//申请ptr成员的内存空间
	int* p = (int*)malloc(sizeof(int) * P_SIZE);
	if (p == NULL)
	{
		return 1;
	}
	else
	{
		ps->ptr = p;
	}
	//使用
	int i = 0;
	printf("请输入你想输入的四个数字:>\n");
	for (i = 0; i < P_SIZE; i++)
	{
		scanf("%d", &ps->ptr[i]);
	}
	printf("调整前的数字:>\n");
	for (i = 0; i < P_SIZE; i++)
	{
		printf("%d ", ps->ptr[i]);
	}
	printf("\n");
	//调整
	int* pa = (int*)realloc(ps->ptr, sizeof(int)* RESIZE);
	if (pa == NULL)
	{
		return	1;
	}
	else
	{
		ps->ptr = pa;
	}
	printf("请输入你想要调整输入的六个数字:>\n");
	for (i = P_SIZE; i < RESIZE; i++)
	{
		scanf("%d", &ps->ptr[i]);
	}
	printf("调整后数字:>\n");
	for (i = 0; i < RESIZE; i++)
	{
		printf("%d ", ps->ptr[i]);
	}
	//释放空间
	free(ps->ptr);
	ps->ptr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

运行展示：

这里就只是关注数组的内容。

2.5 柔性数组的优势

上面我们使用了两种方式实现结构体的调整。

共同点：通过观察我们观察到对柔性数组还是指针，都要用到动态内存管理来进行开辟内存空间，因为结构体在创建的时候就已经每个成员都有自己的内存空间了，但是这里的柔性数组没有大小，所有就只留下了一个地址，用指针方式的场景也是一样只留下了一个地址，所以这里都要用到动态内存管理来开辟空间。
不同点：指针方式的场景中我们使用了两次动态管理开辟空间，这里就需要很多冗余的操作（释放、保证返回的存储指针有效性），这样就会在写的中途出现很多手误。我们要注意一个问题，就是指针方式的场景中，有两次动态内存管理，这时我们不知道内存申请的时候是怎么使用内存空间的，有可能就出现内存碎片了，而使用柔性数组的方式就会出现这种情况。

怎么理解内存碎片？

也就是说在内存使用的时候malloc有可能申请的空间和上一个malloc申请的空间中间间隔的一片内存空间，这时这里的空出来的内存空间就叫做内存碎片。当然这是一种可能性，也会没有。

总结：

柔性数组的优势：

1. 方便内存释放
2. 利于访问速度，减少了内存碎片。

这里就讲解完了。继续努力！