这期我们来看动态内存管理的相关知识，话不多说，我们来看今天的正题

1.为什么要有动态内存管理？

2.动态内存函数的介绍

2.1.malloc和free

2.2.calloc

2.3.realloc

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

3.2 对动态开辟空间的越界访问

3.3 对非动态开辟内存使用free释放

3.4 使用free释放一块动态开辟内存的一部分

3.5 对同一块动态内存多次释放

3.6 动态开辟内存忘记释放

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

5.柔性数组

5.1柔性数组特点

5.2柔性数组的优点

1.为什么要有动态内存管理？

在我们平时写代码时，我们创建的变量都会开辟空间，比如我们创建一个int类型的数据，要开辟4字节的空间，创建一个int arr[10]，需要开辟40个空间，这样开辟空间有两个特点

1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配

对于一些问题，我们传统的创建变量是无法解决的，比如我们的通讯录，可以存储100个人的信息，但对于不同的人有不同的需求，有人可能需要存储200个人的信息，有人可能只需要存几个，对于需求多的人数量不够，对于需求少的人空间又会浪费，这时，我们就可以使用动态内存管理来解决问题

2.动态内存函数的介绍

我们知道我们的局部变量，函数的形式参数等等都是在栈区开辟空间，而栈区的空间有时候是不够用的，我们的内存一般被分为3个区域，栈区，堆区，静态区（全局变量就在静态区），堆区的空间非常大，而且可以被我们使用，我们接下来介绍的四个函数，就是作用于堆区的

2.1.malloc和free

如同它介绍的一样，开辟内存空间，从堆内存上申请size大的空间，返回一个指向这块空间起始位置的地址，这里我们只是申请了这么大的空间，但里面要存放什么内容，int还是double之类我们并不知道，所以返回类型为void*

int* p = (int*)malloc(40);

这就是我们申请了一块空间大小为40个字节的代码，我们要申请空间来使用，我们自己不可能不知道这块空间要放什么内容，比如我想存放int类型数据，所以接收的指针为int*，又因为malloc返回类型为void*，两边类型不同，所以需要强制类型转换，既然是我们申请空间，就有可能会申请失败，申请失败会返回一个空指针

这是我们使用动态内存管理来实现打印出1到10的一个例子，但是，这样写是有一个错误的，我们用malloc从堆区申请了空间，就像我们去图书馆借书一样，有借就要有还，如果不还，其实在这个程序结束时也会将我们申请的空间还给操作系统，但是如果这个程序一直不结束（比如服务器），我们又不还，那这块空间就被浪费掉了

要归还空间，就要使用free函数

我们只需把指向我们申请空间的指针传给free就可以释放空间

在我们释放空间后，其实还没有结束，我们释放空间后，p指针还记录着我们申请的那块空间的地址，如果有人通过p去访问空间，就会形成非法访问，free并不会主动将指针置为空，所以需要我们手动来置空指针

接着我们来看一个申请失败的例子

INT_MAX是一个21亿多的数字，所以会申请失败，我们看strerror给我们返回的错误就是没有那么大的空间

我们在开辟空间时，如果传入的参数size为0，即malloc(0)，这种情况是c语言标准未定义的，结果取决于编译器

同样的，free的参数得是我们动态开辟的，如果不是动态开辟的空间，那free函数的行为也是未定义的，同时，如果传入的参数为NULL，则函数什么事都不会做

2.2.calloc

calloc也是用来动态开辟空间的，但它的参数和malloc是有差异的，num是元素个数，size是每个元素的大小，相当于把malloc的参数细致化，我们来看个例子

我们同样要判断申请空间是否为空，这里我们使用perror即可，我们发现，这次我们并没有对空间里的内容进行初始化，但打印出的元素都为0，那malloc呢？

我们发现malloc并没有对数据进行初始化，而calloc会对数据进行初始化，所以我们使用时需要注意，如果我们不希望这块空间被初始化时可以使用malloc，希望被初始化可以使用calloc，我们可以想象到，malloc因为没有进行初始化，所以效率其实更高一些，当然，我们要根据自己的实际情况选择，使用哪一个都行

2.3.realloc

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时
候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小
的调整。

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

int main() {
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL) {
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++) {
		*(p + i) = i;
	}
	//空间不够，增加5个整形空间
	int* ptr = (int*)realloc(p, 10 * sizeof(int));
	return 0;
}

realloc申请是有两种情况的

情况1
当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2
当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。
由于上述的两种情况，realloc函数的使用就要注意一些

在情况1时，在原空间后接上后续新空间，然后会返回旧的起始地址

在情况2时，在申请完新空间后，会把旧空间的数据拷贝到新空间前面的位置，并且会把旧空间释放掉，同时返回新空间的地址

realloc扩容失败会返回NULL，所以我们使用realloc时不能使用旧的指针来接收空间，万一开辟失败，我们的旧指针就指向NULL了，我们原来的数据就找不到了

所以如果我们还想使用旧指针的话可以这样写，如果之后不会再使用ptr的话，再加上将ptr置为空即可

另外，无论是哪种情况，后续空间的元素并不会初始化

另外，我们在给realloc传参时，如果第一个参数为空指针，realloc的功能就相当于malloc

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

int main() {
	int* p = (int*)malloc(100);
	int i = 0;
	for (i = 0; i < 20; i++) {
		*(p + i) = 0;
	}
	return 0;
}

我们在申请完空间后，一定要记得判断空间是否申请成功，如果申请失败，后续操作就会出现非法访问的问题

我们编译后用鼠标指上去会发现编译都在警告

3.2 对动态开辟空间的越界访问

int main() {
	int* p = (int*)malloc(100);
	if (p == NULL) {
		return 1;
	}
	int i = 0;
	for (i = 0; i < 100; i++) {
		*(p + i) = 0;
	}
	return 0;
}

如果我们稀里糊涂的将100个字节空间当做了100个整形，就像上面代码这样，就形成了越界访问

编译器也会发出警告

3.3 对非动态开辟内存使用free释放

int main() {
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
}

我们写代码时有可能写出成百上千行的代码，变量太多时我们可以忘记了某些变量是什么，就会出现这种情况，当我们这样运行时，程序不出意外的挂掉了

3.4 使用free释放一块动态开辟内存的一部分

int main() {
	int* p = (int*)malloc(100);
	if (p == NULL) {
		return 1;
	}
	int i = 0;
	for (i = 0; i < 25; i++) {
		*p = i;
		p++;
	}
	free(p);
    p=NULL;
	return 0;
}

当我们写出这样的代码时，会发现p指针释放时已经不再指向我们申请内存时的起始位置了，我们释放时一定要传起始地址才行，当程序运行时，代码也会挂掉

3.5 对同一块动态内存多次释放

int main() {
	int* p = (int*)malloc(100);
	if (p == NULL) {
		return 1;
	}
	//使用...
	//释放
	free(p);
	//...
	free(p);
	return 0;
}

当我们代码写多时，可能忘记前面已经释放过空间了，但我们再释放一次，程序就会出现问题

同样的，编译器也会发出警告，执行代码的话程序也会挂掉

我们第一次释放空间后，p就相当于野指针了，再次释放肯定会出现问题

所以我们释放完空间后一定要记住将指针置为空，这些操作都是有意义的

3.6 动态开辟内存忘记释放

int* test() {
	int* p = (int*)malloc(100);
	if (p == NULL) {
		return 1;
	}
	//使用
	return p;
}
int main() {
	int* ptr = test();
	//...
	return 0;
}

我们用一个函数来开辟空间，然后把开辟好的空间传给一个指针时，使用完后一定要记得释放空间，不然会造成内存泄漏，对于上面的test函数，我们一定要写好注释，告诉别人这个函数使用了malloc函数，你在使用这个函数后要记得释放空间才行

比如某些公司的服务器，隔三岔五就会出现问题，一重启就正常了，此时就可能会有这种问题，因为程序在不停的吃内存

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

C/C++程序内存分配的几个区域：

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

有了这幅图，我们就可以更好的理解static关键字修饰局部变量的例子了
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁所以生命周期变长

5.柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员

struct S {
	int n;
	char c;
	char arr[];
};

就像这样，我们定义一个结构体，最后一个元素为数组，数组大小可以不指定，或者写成arr[0]，两种写法会支持一种（不同编译器），或都可以使用，这个数组就叫柔性数组成员

5.1柔性数组特点

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

第一个特点意思是，我们的结构体要使用柔性数组至少要有两个成员变量才行，我们来看个错误例子

struct S {
	char arr[];
};

这个结构体只有柔性数组，是错误的，前面必须有一个元素

第二个特点的意思是我们计算结构体大小时不会计算柔性数组，比如

第三个特点也给我们说明了柔性数组如何创建变量

struct S {
	int n;
	char arr[];
};

int main() {
	struct S s;
	struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(char) * 10);
}

如果我们想让这个数组可以存放10个元素，就如上面代码所示，我们应该用malloc来申请空间，申请空间大小为原结构体大小加上我们想让数组多多少元素大小，如果是int数组就要乘以40，然后依照malloc的使用方法，我们用该结构体的指针来接收，后期我们觉得数组不够用，可以进行调整大小，所以这个数组叫做柔性数组