【C语言】—— 动态内存管理

一、动态内存管理概述

1.1、动态内存的概念

  在了解为什么要有动态内存管理之前，我们得先知道动态内存的定义。

  动态内存是指动态的内存空间，意思就是：能动态开辟的内存空间，动态就是申请了这块空间后，可动态的修改这块空间的大小，根据需要，动态地释放和分配内存空间。
  

1.2、动态内存的必要性

  为什么要有动态内存呢？
  既然有动态内存，那与之相对的就是静态内存
  什么是静态内存呢？其实静态内存我们天天都在用，只是不知道它是静态内存而已
  
下面两种内存开辟方式就是静态内存

int val = 20;//在栈空间上开辟四个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间

  

但是静态内存的开辟有两个缺点：

• 空间开辟的大小是固定的
• 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整

  但是，在实际需求中，我们往往只有在程序运行时才能知道所需的空间大小，用数组开辟空间，往往容易造成内存溢出（空间开小），或者内存浪费（空间开大），无法满足实际的需求
  
  因此，C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，并根据需要，自己调整开辟后空间的大小。这样不仅提高了内存的利用率，也极大地增强了程序的灵活性与扩展性。
  
  

二、 $malloc$ 函数

2.1、函数介绍

  C语言中提供了一个动态内存分配的函数：$malloc$

功能：向内存申请一块连续可用的空间（可当成数组），并返回指向这块空间的指针

• 参数 $size$_$t$ $size$：

  • 分配的内存的大小，以字节为单位。即开辟 $size$ 字节大小的空间
  • 如果参数为 0 ，$malloc$ 的行为是标准未定义的，取决于编译器
      

• 返回值 $void$ *：

  • 返回指向开辟空间的指针，因为 $malloc$ 函数 事先并不知道使用者开辟空间存放什么类型的数据，因此指针为 $void$* 类型，以便能接受所有类型。
  • 使用者可根据自己的需要，将其强制类型转换成自己所需要的类型，以便能进行解引用操作。
  • 如果开辟失败，则返回 空指针，因此 $malloc$ 的返回值一定要做检查

  

2.2、应用举例

#include<stdlib.h>

int main()
{
	int* p = NULL;
	p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc fail");
		return 1;
	}
	return 0;
}

上述代码是使用 $malloc$ 函数开辟 10 个整型变量的空间，也即 40 个字节的空间

• 首先，因为 $malloc$ 函数的返回值是指针，我们需用指针变量 $p$ 接收其返回值，创建 $p$ 时，并不知道其指向的空间，所以先初始化为 NULL。
• 接着，使用 $malloc$ 函数开辟空间，因为我们要存放的是整型变量，而 $malloc$ 的返回值类型为 $void$* 我们通过强制类型转换将其返回类型转换为 $int$* ，并用 $p$ 来接收
• 因为 $malloc$ 函数有可能开辟失败¹，只有当返回值不为空的情况我们才使用它，因此需判断 $p$ 指针是否为空。若为空，则用 $perror$ 函数²打印出错误信息，并返回 1³。
• 若开辟成功，我们就可以愉快地使用这块空间啦

  需要注意的是：$malloc$ 开辟的空间并不会将其初始化
  
  

三、$calloc$ 函数

  开辟动态内存空间，C语言还提供了一个函数叫 $calloc$ ，原型如下：

• 函数的功能是为 $num$ 个大小为 $size$ 的元素开辟一块空间，并将这块空间初始化为 0
• 与函数 $malloc$ 的区别只在于 $calloc$ 会返回地址之前把申请的空间的每个字节初始化为全 0

举个例子：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf(" %d", *(p + i));
		}
		printf("\n");
	}
	return 0;
}

  
运行结果：

  
  

四、$free$ 函数

4.1、函数介绍

  
  上述 $malloc$ 函数、$calloc$ 函数以及后面讲的 $realloc$ 函数所申请的空间，并不满足作用域的规则。只有当程序退出时，用他们开辟的动态空间才会归还给操作系统，换言之，程序不退出，就不会主动归还空间。这时，我们就需要 $free$函数 来对其主动释放

  $free$ 函数是专门用于动态开辟的内存空间的释放和回收，声明如下：

  
$free$ 函数用来释放动态开辟的内存

• 如果参数 $ptr$ 指向的空间不是动态开辟的，那 $free$ 函数的行为是未定义的
• 如果参数是 $ptr$ 是NULL指针，则函数什么事都不做
• 需要注意的是，$free$ 函数不会改变指针所指向的值，释放后它依然指向相同的内存空间。因此我们要手动将释放后的 $ptr$ 置空，避免出现野指针。

$malloc$、$calloc$ 以及 $free$ 函数的声明都在 $<stdlib.h>$ 中
  

4.2、应用举例

  
我们来看个例子：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(10 * sizeof(int));
	if (NULL != ptr)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

  
  那我们来看看下面这种情况行不行呢？

int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(5 * sizeof(int));
	if (NULL != ptr)
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*ptr = 0;
			ptr++;
		}
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

  当然是不行的，为什么呢？
  因为传递给 $free$ 函数的是要释放空间的 起始地址
  上面函数的 $ptr$ 以及不再指向要释放空间的起始地址了，当然是不行的。
  
  

五、$realloc$ 函数

5.1、函数介绍

  
  可能有小伙伴问：前面你说动态内存可根据需要，动态调整所开辟空间的大小，但前面介绍 $malloc$、$calloc$ 以及 $free$函数 都只是在将动态空间的开辟和释放，如何调整空间的大小呢？别急，我们接下来要讲的 $relloc$函数 就是完成调整开辟空间的大小的任务的

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

先来看看 $relloc$函数 的声明：

• $ptr$ 是要调整的内存地址
• $size$ 是调整之后的大小（可以变大，也可变小）
• 返回值为调整之后的内存起始位置

$realloc$ 调整内存大小分为三种情况：

1. 原有空间之后有足够大的空间

  如上图：$relloc$ 已经开辟 20 个字节的空间，现在我想扩容到 40 字节，同时原有空间后方空间足够扩展新空间
  
  此时 $realloc$ 函数直接在后方追加空间，原来空间的数据不发生变化

  
2. 原有空间之后没有足够大的空间

  还是上面那个图，现在我想将他扩容到 400 字节，很明显，已开辟空间后方没有足够的空间，总不能把别人踢开，自己霸占吧
  这时，$realloc$ 函数就会在堆空间 另外找一个 合适大小的空间。
  
具体流程如下：

• $realloc$ 函数先在堆空间上找一块新的空间，并且满足大小要求
• 后将旧空间的数据拷贝到新空间中
• 接着释放旧空间
• 最后返回新空间的起始地址

  
3. 空间调整失败

  $realloc$ 可能出现空间调整失败的情况，此时返回的是空指针

  
  
  $realloc$ 不仅仅能将空间的变大，还能将空间变小，只需要第二个参数的值小于原空间的大小就好了，因为缩小空间比较简单，这里就不再过多介绍，但需要注意的是，缩小空间可能会造成数据丢失，因此需小心使用

  同时 $realloc$函数 不仅能调整空间大小，还能完成 $malloc$函数 的功能：当第一个参数 $ptr$ 传递的是 空指针 时，$realloc$ 函数就不再是调整空间大小了，你都没空间，我还怎么调。此时$realloc$ 函数会 新开辟 $size$ 字节大小的空间。
  
  

5.2、应用举例

  看了上面三种情况，大家想一想，应该怎样接收 $realloc$ 调整之后的返回值呢？
  可以直接用原来的指针 $p$ 接收吗？

  显然是不行，如果 $realloc$ 调整成功，那确实没问题，但如果失败了呢？此时返回的是空指针。本来 $p$ 还维护着原来的空间，现在直接变空指针，那原来的空间再也找不到了，这就造成了内存泄漏。

  正确的方法是创建新的指针 $ptr$ 来接收，当 $ptr$ 不为 NULL，再将 $ptr$ 的值传给 $p$
  
如下：

#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc fail");
		return 1;
	}
	//1 2 3 4 5
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

	//希望将空间调整为40个字节
	int* ptr = NULL;
	ptr = (int*)realloc(p, 40);
	if (NULL != ptr)
	{
		p = ptr;
	}
	else
	{
		perror("realloc fail");
	}

	//调整成功，使用40个字节；调整失败，继续使用20个字节

	/**************
	
	业务处理

	**************/

	free(p);
	p = NULL;
	return 0;
}

  
  

六、常见的动态内存错误

6.1、对NULL指针进行解引用

  

#include<stdlib.h>

int main(
{
	int* p = (int*)malloc(INT_MAX);
	*p = 20;//如果p的值是空指针，就会有问题
	free(p);
	p = NULL;
	return 0;
}

  
  动态开辟的空间，应该先对返回值进行判断，确保空间开辟成功
  上述代码所要开辟的空间太大，开辟失败，返回的是空指针，而下面一句代码对空指针进行解引用，是错误的
  

#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10 * INT_MAX);
	if (NULL == p)
	{
		perror("malloc fail");
		return 1;
	}

	*p = 20;
	free(p);
	p = NULL;
	return 0;
}

  

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

  

#include<stdlib.h>

int mian()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

  可以看到，当 $i$ = 10 时，就是对 $malloc$ 开辟的空间越界访问了。
  动态内存的空间与数组是非常相似的，要注意不能对其越界访问。
  

6.3、对非动态开辟的内存使用 $free$ 释放

void test()
{
	int a = 10;
	int* p = &a;
	free(p);//ok?
}

  变量 $a$ 并不是动态开辟的变量，用 $free$ 释放是错误的
  
  

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

  这种情况即是，传给 $free$ 的指针并不是动态开辟内存的起始地址，指针跑后面去了。

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//p不再指向动态内存的起始位置
}

  注意：动态内存一定是 一同申请，一同释放。无法做到只释放一部分空间
  

6.5、对同一块动态内存多重释放

void test()
{
	int* p = (int*)malloc(100);
	//···
	free(p);
	free(p);//重复释放
}

  这种释放有办法可以避免：释放完后及时把 $p$ 置为空指针，这样，即使再次释放，传的是空指针，$free$ 什么都不会做，不会造成什么影响
  

6.6、动态开辟内存忘记释放（内存泄漏）

#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}

int main()
{
	test();
	while (1);
	return 0;
}

  上述代码，你会发现，一旦出了函数，就再也找不到开辟的那 100 个字节的空间(这代码写的比较极端，一直死循环，程序一直不结束) 。找不到开辟的空间更别提将其释放，空间就一直在那占着，就造成了内存泄漏。

  想一想，如果我们一直向内存申请空间，但从来不释放。要知道，内存的总大小是有限的，这样就会把内存耗干，机器就挂了。

  
总结： 用 $malloc$、$calloc$、$realloc$ 申请的空间，尽量做到：

• 谁（可能是函数）申请的就谁释放，即 $malloc$ 和 $free$ 成对出现
• 如果不能释放，要告诉使用的人记得释放

  
  

七、动态内存经典笔试题分析

7.1、题一

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}

int main()
{
	Test();
	return 0;
}

请问运行 $Test$ 函数会有什么样的结果？

运行 $Test$ 函数，程序会崩溃！
  
为什么呢？我们来分析一下
  
先来看这段代码想要做什么：

1. 首先，它定义了一个 $GetMemory$函数，很明显，这个函数是完成动态开辟空间任务的
2. 接着 $Test$函数 中创建了指针 $str$，将变量传给 $GetMemory$，即希望指针 $str$ 管理动态开辟的空间
3. 最后往空间中存入 $"helloworld"$，并打印

  
  代码的逻辑没问题，那就是代码本身出问题咯

  通过调试我们发现，$GetMemory$函数 并没有改变 $str$ 的值，它依然是个空指针。

  为什么呢？因为 $GetMemory$是 传值传参，而不是传址传参！传值传参无法改变主调函数中的值，出了函数 $str$ 依然是空指针，而后面打印 $str$ 指向的内容，是要对其解引用的，对空指针解引用自然会出问题。
  同时，函数中 $malloc$ 是实打实开辟了空间的，只有程序结束才销毁，而函数中的变量出了函数作用域就销毁，这样函数中所开辟的 100 个字节空间出了 $GetMemory$函数 后也无法找到，造成内存泄漏=

  可能有小伙伴会问：$GetMemory$函数 的参数类型就是 $char$* 啊，为什么还是传值传参呢？这里我们要指针传址传参的本质：传递的是变量的地址，因为主调函数中要传的值本身就是指针 $char$* 类型，要改变指针变量，就要传递指针变量的指针，即二级指针。这里可不敢看到 $GetMemory$函数 参数中是 $char$* 就认为他是传址传参
  
正确写法应该是这样：

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	//传str的地址
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	//释放动态空间
	free(str);
	str = NULL;
}

当然，$GetMemory$函数 我们也可以直接让他返回 $p$，以实现目的

char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}

void Test(void)
{
	char* str = GetMemory();
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}

  
  

7.2、题二

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();
	return 0;
}

运行结果：

  为什么会这样呢？
  问题还是出在 $GetMemory$函数

  $GetMemory$函数 中创建的 $p$ 数组，在出了函数作用域后就销毁了，因此函数返回 $p$，用$str$ 接收，而实际上 $str$ 接收的地址是指向一块已经归还的空间，此时的 $str$ 是野指针。再去访问 $str$ 所指向的空间是非法访问，打印出的值是随机值。
  
  

7.3、题三

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

  可能有小伙伴会觉得这段代码咋一看好像没什么问题啊

  确实，大家有没有发现代码与我们第一题修改后的代码非常像，但大家仔细想想它还缺少什么？

  这段代码唯一的问题是：没有 $free$，动态申请内存空间后他并没有还回去。

  虽然这里没有 $free$ 程序也没有问题，因此程序结束后会自动释放空间，但以后遇到复杂的情况就不好说了，因此我们要 养成主动释放内存空间的习惯
  
  

7.4、题四

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

  这题的问题相信大家都能看得出来：
  
  $Test$函数 上来先开辟 100 字节动态空间，并创建 $str$ 变量维护它，再向空间中放 $"hello"$
  
  但紧接着，释放 $str$，却没将 $str$ 置空，此时的 $str$是野指针。将空间释放，即将其还给操作系统，我们是没有使用权限了，但是这块空间本身还在
  
  下面的 $if$ 语句判断为真，往 $str$ 指向的空间放入 $"world"$，此时 $str$ 指向的空间我们已经没有使用权限了，但依然进行修改，为非法内存访问。
  
  

八、柔性数组

8.1、什么是柔性数组

  
  也许有些小伙伴从来没有听过柔性数组这个概念，但是它确实是存在的
  C99 中，结构体的最后一个元素允许是未知大小的数组，这就叫做：柔性数组成员。
  

typedef struct st_type
{
	int i;
	int a[0];
}type_a;

  有些编译器会报错无法编译，可以改成：

typedef struct st_type
{
	int i;
	int a[];
}type_a;

  
  

8.2、柔性数组的特点

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

例如：

typedef struct st_type
{
	int i;
	int a[0];
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));
	return 0;
}

运行结果：

  
  

8.2、柔性数组的使用

#include<stdio.h>
#include<stdlib.h>

typedef struct st_type
{
	int i;
	int a[0];
}type_a;

int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc fail");
		return 1;
	}
	//业务处理
	p->i = 10;
	for (i = 0; i < 10; i++)
	{
		p->a[i] = i;
	}
	//调整空间
	type_a* ptr = (type_a*)realloc(p, sizeof(type_a) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	free(p);
	p = NULL;
	return 0;
}

柔性数组的结构：

  既然这块空间是 $malloc$ 出来的，也就是说他可以通过 $realloc$ 来调整大小，所以这个数组可变长变短，不就是柔性吗
  
  

8.3、柔性数组的优势

  
  上述 $type$_$a$ 结构，也可以设计为下面的结构，也能完成同样的效果

#include<stdio.h>
#include<stdlib.h>

typedef struct st_type
{
	int i;
	int* p_a;
}st_type;
int main()
{
	st_type* p = (st_type*)malloc(sizeof(st_type));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));

	///业务处理
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}

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

图示：

  上述两个方法都可以达到类似的效果

  但是使用柔性数组有两个好处：
  

• 方便内存释放
    如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把结构体返回给用户。用户调用 $free$ 可以释放结构体，但是用户并不知道结构体内的成员也需要 $free$，所以你不能指望用户来发现这个事。
    所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次 $free$ 就可以把所有的内存释放掉
    
• 有利于访问速度
    连续的内存有益于提高访问速度，也有益于减少内存碎片⁴

  
  

九、C/C++中内存区域划分

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

• 内核空间：操作系统核心（内核）运行的地方，在这个区域，操作系统可以直接访问硬件，并执行特权指令。我们用户是无权访问这块空间的
• 栈区：在执行函数时，函数内局部变量的存储单元都是在栈上创建，函数执行结束时这些存储单元自动释放。栈内存分配运算内置于处理器的指令中，效率很高，但是分配的内存容量有限。栈区只要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
• 堆区：堆区一般是用来存储程序运行期间动态分配内存的地方。堆区的内存分配是在程序运行时动态进行的，程序员可以通过调用标准库函数（如$malloc$、$calloc$、$realloc$等）来在堆区中分配内存，并在不需要时手动释放这些内存（使用$free$函数）。使用堆区需要注意内存泄漏（$memoryleak$）的问题，即程序在不再需要某块内存时没有释放它，导致程序占用的内存越来越多。
• 数据段：数据段也叫做静态区，主要用来存放全局变量、静态数据、全局变量。程序结束后由系统释放
• 代码段：存放函数体（类成员函数和全局函数）的二进制代码、只读常量（字符串常量）

---

1. 内存开辟失败：动态内存开辟失败的原因一般都是所空间太大，没有足够的空间 ↩︎

2. $perror$函数：有关该函数的具体介绍请看：《【C语言】——字符串函数的使用与模拟实现（下）》 ↩︎

3. 返回值为 1：$main$ 函数程序正常退出，返回值为 0；异常退出，返回值为 1 ↩︎

4. 我们开辟内存时，不会紧接着上一块内存开辟，而会留下一点空隙，开辟次数越多，留下的空隙也就也多，这些空隙称为内存碎片。 ↩︎