C语言动态内存管理（三）

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

1.图解

（1）内核空间：留给操作系统内核用，用户不能使用，自己写的程序没有权限访问内核空间
（2）栈区：存放局部变量
（3）内存映射段：（在Linux专栏中介绍）
（4）堆区：malloc,calloc,realloc动态开辟的空间

✨关于realloc在C语言动态内存管理（一）中讲了调整动态内存空间的作用，这里补充realloc函数的第一个参数是空指针NULL的时候，作用相当于开辟内存空间
举例：
realloc(NULL,20);
这句代码相当于malloc(20);

（5）数据段：存放全局变量，静态变量（静态变量不管是全局的还是局部的都放在数据段中）
（6）代码段：自己写的代码编译之后的汇编指令或者二进制指令

2.关键点

（1）栈区：
I.函数内的局部变量进作用域创建，出作用域销毁
II.向栈区申请的空间是有限的，不断地向栈区申请空间，就会出现栈溢出现象
III.栈区主要存放运行函数而分配的局部变量，函数参数，返回数据，返回地址等。
（2）堆区
一般由程序员分配释放。若程序员不释放，程序结束时可能由操作系统回收。分配方式类似于链表。
（3）数据段（静态区）
存放全局变量，静态数据。程序结束后由系统释放
（4）代码段
存放函数体（类成员函数和全局函数）的二进制代码

六、柔性数组

1.什么是柔性数组

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

2.两种语法形式

✨第一种：结构体中最后一个数组的大小指定为0

struct S {
	int n;
	int a[0];//柔性数组成员
};

✨第二种：结构体中的最后一个数组未指定大小

struct S {
	int n;
	int a[];//柔性数组成员
};

3.柔性数组的特点

（1）结构中的柔性数组成员前面必须至少有一个其他成员
（2）sizeof返回的这种结构大小不包含柔性数组的内存

也就是说包含柔性数组成员的结构体在用sizeof算这个结构体大小时，不计入柔性数组的大小

（3）包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小
✨注意：
包含柔性数组成员的结构体创建时与一般结构体创建的方法不同。不能直接创建写成struct S ss;

4.柔性数组的创建及使用

柔性数组方案一

//柔性数组方案一
#include
#include
#include
#include

struct S {
	int n;
	char c;
	int arr[0];//柔性数组成员
};
int main() {
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	/*
	(1)内存中放的是struct S类型的数据，开辟空间的地址应该是struct S*
	(2)结构体大小：包含除柔性数组成员的其他成员
	(3)10*sizeof(int)是柔性数组里打算放的东西，为柔性数组留了10个整型
	
	*/
	//判断是否开辟成功
	if (ps == NULL) {
		printf("%s\n",strerror(errno));
		return 1;
	}
	//使用
	ps->n = 55;
	ps->c = 'y';
	int i = 0;
	for (i = 0; i < 10; i++) {
		ps->arr[i] = i;
	}
	for(i = 0; i < 10; i++) {
		printf("%d\n", ps->arr[i]);
	}
	//调整arr数组的大小
	struct S* ptr = (struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
	if (ptr == NULL) {
		printf("%s\n", strerror(errno));
		return 1;
	}
	else {
		ps = ptr;//开辟成功的话最好用原来维护开辟好的空间的ps指针来维护这块空间
	}
	//使用
	//...

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

	return 0;
}

在这个方案中柔性数组的柔性怎么体现出来的?

✨如果将结构体中arr长度写做10，结构体类型一旦创建好了，数组大小就不能改变了。不能每次使用的时候才进行更改数组的长度，因为一旦编译，结构体中的数组大小就固定了。
✨而柔性数组成员的空间是malloc出来的，malloc的空间可用realloc调整，那么这个数组的大小就柔性可变了。

5.不用柔性数组，实现数组可大可小的思路

结构中指针方案二

#include
#include
struct S {
	int n;
	char c;
	int* arr;
};
int main() {
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL) {
		perror("malloc");
		return 1;
	}
	int* ptr = (int*)malloc(10 * sizeof(int));
	if (ptr == NULL) {
		perror("malloc");
		return 1;
	}
	else {
		ps->arr = ptr;//开辟成功，把地址交给arr,arr指向这块空间
		/*
		arr指向这块空间，那么arr就可以像数组一样访问这块空间
		这块空间是malloc来的，所以不够时就可以用realloc进行扩容
		*/
	}

	//使用
	ps->n = 100;
	ps->c = 'y';
	int i = 0;
	for (i = 0; i < 10; i++) {
		ps->arr[i] = i;
		/*
		因为arr里面放的是这块空间的起始地址，和数组名一样
		把这块空间想象成连续的数组，数组名表示首元素的地址
		*/
	}
	//打印
	for (i = 0; i < 10; i++) {
		printf("%d ", ps->arr[i]);
	}
	//扩容-->调整arr数组的大小
	ptr = realloc(ps->arr, 20 * sizeof(int));
	if (ptr == NULL) {
		perror("realloc");
		return 1;
	}
	else {
		ps->arr = ptr;
	}

	//使用
	//...

	//释放
	//注意：释放动态内存开辟空间的顺序：后开辟的先释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

6.对比

柔性数组方案一：
（1）malloc一次free一次
容易维护空间，不易出错
（2）malloc次数少，内存碎片较少，内存的使用率就会高一些
（3）有利于访问速度

柔性数组在内存空间中是连续的
涉及到局部性原理：
如果内存是连续的，拿数据进行内存访问时，不是直接去拿，而是把内存中数据加载到寄存器里面。如果使用某个位置的数据，寄存器后面有空的话就会紧接着把它后面的数据加载到寄存器中。如果使用后面数据的话，在寄存器中已经拿到了，这样的效率更高。
在结构中指针方案二：
开辟了两块不连续的空间，在访问其中一块空间的时候，不断加载的事该空间后面的数据到寄存器，并没有把另一块空间的数据加载。访问另一块空间的数据时，寄存器中没有找到，跑到内存中去找，此时整体的效率就下降了。

总结

关于动态内存管理的全部知识就分享到这里啦，哪里有问题的话，欢迎各位朋友在评论区留言，可以点赞收藏博客关注后续的内容哦