C语言：动态内存管理

动态内存管理
柔性数组
C/C++内存分配

动态内存管理

C语言的动态内存管理是指程序在运行时可以动态地申请和释放内存。

C语言中，动态内存管理主要通过函数来实现，接下来我们就讲解这些函数。
以下函数使用前需要包含<stdlib.h>头文件

malloc

malloc函数用于申请指定大小的内存空间。它接收一个参数，即所需内存的字节数，并返回一个指向该内存块的指针。如果申请失败，则返回NULL。

示例：

malloc(sizeof(int) * 10);

这就申请到了10个int类型的空间，那么我们要如何使用这个空间呢？

malloc申请成功后，会返回指向该内存的指针

观察malloc函数的定义，我们会发现malloc的返回值是void*类型的指针。这种指针是不能解引用的，所以使用前需要强制类型转化。

示例：

int* p = (int*)malloc(sizeof(int) * 10);

由于我们希望内存内存储int类型的数据，所以我们把malloc的返回值转化为int*类型的指针。

但是malloc也有可能会开辟空间失败，比如内存不够了，此时malloc会返回NULL。如果开辟失败，那么我们最好中止程序，因为malloc如果申请不到内存了，说明当前程序很可能发生了问题。

int* p = (int*)malloc(sizeof(int) * 10);
if(p == NULL)
{
	perror("malloc fail!");//返回错误信息
	exit(-1);//退出程序
}

以上就是一个标准的内存申请过程：

申请内存

得到强制类型转化后的指针

检查有没有开辟成功

free

在这里插入图片描述
free函数用于释放之前程序员申请的内存空间。它接收一个参数，即要释放的内存块的指针。

比如这样：

char* p = (char*)malloc(sizeof(char) * 10);
free(p);

我们一开始通过malloc开辟了一段空间，然后通过free把它释放掉了。

当我们把p指向的内存释放掉后，p就变成了野指针，此时要注意及时置空。

p = NULL;

注意事项：

如果参数指向的空间不是通过malloc，calloc，realloc开辟的，那么free的行为是未定义的，所以free只用来释放动态开辟的内存
如果给free传入NULL，那么free什么也不干

calloc

在这里插入图片描述
calloc函数用于申请指定数量和大小的内存空间，它接收两个参数，即所需内存块的数量和每个内存块的字节数，并返回一个指向该内存块的指针。如果申请失败，则返回NULL。

示例：

int* p = (int*)calloc(10, sizeof(int));

以上代码，完成了10个int类型数据所需的空间开辟。

我们看到完成相同功能的malloc：

int* p = (int*)malloc(sizeof(int) * 10);

有没有发现，两者几乎没有区别？
是的，这两个函数就是几乎没有区别，但是有一个区别就是：
通过calloc申请的空间，每个字节都会被初始化为0，而malloc没有初始化的行为。

大部分情况下，我们用malloc居多。

realloc

在这里插入图片描述

realloc函数用于重新分配已经申请的内存空间的大小。它接收两个参数，即原始内存块的指针和新的大小，并返回一个指向重新分配后内存块的指针。如果重新分配失败，则返回NULL。

也就是说，我们可以通过calloc调整原先分配的内存大小。

示例：

int* p = (int*)malloc(sizeof(int) * 10);
p = (int*)calloc(p, sizeof(int) * 20);

以上代码，我们先通过malloc开辟了10个int类型所需的空间，然后再通过calloc扩大了内存，将原先的内存扩大至20个int类型。这也是动态内存管理最重要的功能：可以自行调节内存的大小。

需要注意的是：realloc开辟内存后，内存有可能和之前不是同一块区域。

realloc的扩容有两种情况：

以该情况为例：

int* ptr = (int*)malloc(sizeof(int) * 5);
ptr = (int*)calloc(ptr, sizeof(int) * 10);

一开始有20字节空间，即5个int类型。现在我们需要将其扩大到40字节。

原地扩容：

看到以下内存：
在这里插入图片描述

一开始我们有左侧绿色框内的20byte的内存，在这个内存后面，有一块虚线的绿色内存，其没有被分配，说明当前内存后面还有足够大的空间进行扩容，此时就会发生原地扩容，即直接把后面的绿色虚线区域也变成动态管理的内存。此时ptr指针的指向没有改变。

异地扩容：
看到以下内存：
在这里插入图片描述
一开始我们有左侧绿色框内的20byte的内存，在这个内存后面，有一块虚线的绿色内存，其没有被分配，但是我们需要额外得到20byte，但是当前内存后面剩余的空间不够，此时就会发生异地扩容，即重新找一块足够40byte的空间，然后在新的区域创建动态内存。此时ptr指针的指向改变了。

注意事项

在申请内存之前，应该先判断申请是否成功，即返回的指针是否为NULL。如果申请失败，应该进行相应的错误处理。
在使用完动态分配的内存后，应该及时释放内存，以避免内存泄漏。如果不释放内存，程序的内存使用量会不断增大，最终导致系统资源耗尽。
动态内存操作的内存，都是堆区的内存

总之，C语言的动态内存管理提供了灵活的内存分配和释放机制，可以根据程序的需要动态地调整内存空间的大小。但是，使用动态内存管理需要谨慎，避免内存泄漏和内存错误的发生。

柔性数组

柔性数组是在C99标准后才出现的，它是指：对于动态内存中的结构体的最后一个成员，可以放一个长度可以改变的数组。

//方法1
struct st
{
	int a;
	int arr[];//柔性数组成员
}
//方法2
struct st
{
	int a;
	int arr[0];//柔性数组成员
}

根据定义可知，柔性数组必须是结构体的最后一个成员。在上述开辟过程中，我们都在结构体末尾放了一个数组，此数组的[]内部没有值或者值为0。这就是柔性数组的基本语法，若数组不是最后一个成员，或者数组[]内有0以外的值，最后创建的都不是柔性数组。注意：部分编译器只支持其中一种写法。

柔性数组有以下特性：

柔性数组成员前至少有一个其它成员

sizeof计算结构体的大小时，不计入柔性数组成员

柔性数组的长度变化由malloc与realloc决定，在第一次使用malloc开辟内存时，必须大于结构体其它成员占用内总和，多出来的内存分配给柔性数组。

为了理解这些特性以及柔性数组的长度变化，我们来分析一串代码：

struct st
{
	int a;
	int arr[];//柔性数组成员
};

int main()
{
	struct st* p = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));
	//为结构体开辟空间，并为柔性数组开辟空间存放10个元素
	if (p == NULL)//检查开辟空间是否成功
	{
		perror("malloc");
		return 1;
	}
	//为柔性数组的元素赋值
	int i = 0;
	p->a = 100;

	for (i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}
	//感觉数组长度不够，增长数组：
	struct st* ptr = realloc(p, sizeof(struct st) + 15 * sizeof(int));
	//增加5个元素的空间
	if (ptr == NULL)//检查开辟空间是否成功
	{
		perror("realloc");
		return 1;
	}
	else
	{
		p = ptr;
		ptr = NULL;
	}
	//对后续开辟的5个空间赋值
	for (i = 10; i < 15; i++)
	{
		p->arr[i] = i;
	}

	//释放空间
	free(p);
	p = NULL;
	return 0;
}

柔性数组开辟：

struct st* p = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));
一开始我们创建了一个结构体，在利用动态内存开辟了属于结构体本身的空间后，追加了10个int类型的大小，用于存放柔性数组的元素。
此处也利用了sizeof不计算柔性数组的特性，避免程序员自己计算结构体的大小，追加的空间也更加直观。

柔性数组增长：