C语言动态内存分配详解

前言

自从前两次博客写完以后，感觉对于我本人来说，收获很大，尤其是将学过的知识再度温习一遍，感觉基础扎实了很多，所以就养成了一个习惯，每学完一个模块，都会写一篇博客，不仅仅是写个我自己的，也是想通过这篇博客，与大家分享一些我的见解。本来周四就学完了动态内存分配，但是周末博主去玩了，于是忘记了写博客，现在加班奉上。

一、为什么存在动态内存分配

1、已掌握的内存开辟方式

在C语言中，我们将内存分为了4个区间：
代码区，全局变量与静态变量区，局部变量区即栈区，动态存储区，即堆（heap）区或自由存储区（free store）。

为了方便大家理解，图解如下：

通过之前的学习，我们了解了一些内存的使用方法：

（1）创建一个变量
当我们想要使用单一变量的时候，我们可以通过创建一个变量，来使用内存。

int a = 10;//局部变量 - 栈区
int g_a = 10;//全局变量 - 静态区

（2）创建一个数组
当我们需要使用多个相同类型变量的时候，我们可以通过创建一个数组，来使用内存。

int arr[10];//局部变量 - 栈区
int g_arr[10];//全局变量 - 静态区

2、上述开辟空间方式的特点

以上两种使用内存的方式是我们学过的，也是常用的，但是在某些情况下，仅仅有这两种方法是不足的。

例如：我们需要创建一个数组来存放一个班级的学生信息的时候。

我们在创建这个arr数组的时候，当我们直接给定数组的长度arr[50]的时候，这样是很简单，但是这样合理吗？
例1：

#include<stdio.h>
struct s
{
	char name[20];
	int age;
};
int main()
{
	struct s arr[50];// 50个struct s 类型的数据
	// 30 ：不够
	// 60 ：浪费
	
	return 0;
}

假设这个班级只有30个人，那么我们是不是就浪费了一部分的空间；假设这个班级有60个人，那么我们给定的50又不够。所以说这里给定多少都是不合理的。

这里有人又会说了，很简单啊：要多少给多少就好了嘛！就像这样
例2：

#include<stdio.h>
struct s
{
	char name[20];
	int age;
};
int main()
{
	int n = 0;
	scanf_s("%d", &n);

	struct s arr[n];//错误(活动)	E0028	表达式必须含有常量值

	return 0;
}

运行结果为：报错

事实证明，我们的想法很美妙，但是现实却很残酷：
这里的错误名称叫:表达式必须含有常量值；
说明对于 struct s arr[n]; 这里的n是变量，那就不行了。

这里延伸一下：例2这种代码的写法叫做变长数组。
对于变长数组这种写法目前仅对于C99是可运行通过的。

总结：上述开辟空间方式的特点
（1）开辟空间的大小是固定的；
（2）数组在声明的时候，必须制定数组的长度，它所需的内存在编译时分配。

3、为什么存在动态内存分配

我们对于内存开辟空间的需求，不仅仅局限于这些方式，有时候我们需要的空间大小在程序运行的时候才能知道，这时上述方式就不能达成目的了，所以动态内存分配就应运而生了。

二、动态内存函数的介绍

1、malloc

C语言提供了一个动态内存开辟的函数：

	void* malloc (size_t size);

malloc的全称是memory allocation，中文叫动态内存分配，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存，且分配的大小就是程序要求的大小。

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
（1）如果开辟成功，则返回一个指向开辟好空间的指针；
（2）如果开辟失败，则返回一个NULL指针，因此 malloc 的返回值一定要做检查；
（3）返回值的类型是 void*，所以 malloc 函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定；
（4）如果参数 size 为 0 ，malloc 的行为是标准是未定义的，取决于编译器。

举一个例子
例3：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	// 向内存申请10个整形的空间
	int* p = (int*)malloc(10 * sizeof(int));
	// malloc -> #include<stdlib.h>

	//int* p = malloc(10 * sizeof(int));
	// 错误	 C2440	 “初始化” : 无法从“void * ”转换为“int* ”
	if (p == NULL)
	{
		// 打印错误原因的一个方式
		printf("%s\n", strerror(errno));
		// strerror -> #include<string.h>
		// errno -> #include<errno.h>
	}
	else
	{
		// 正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	return 0;
}

运行结果为：
0 1 2 3 4 5 6 7 8 9

在例3中，我们如果采用 “ int* p = malloc(10 * sizeof(int)); ” 的方式来开辟空间，在大部分检测严格的编译器中，会报错，这是因为变量类型的不同，从这里我们也可以看出，malloc 开辟空间的返回值是 void* 类型；

上面我们也提到了：如果 malloc 开辟失败，则返回一个NULL指针，所以malloc 的返回值一定要做检查，所以我们用了一种特殊的方式来打印错误原因——“ printf("%s\n", strerror(errno)); ” ，这样如果开辟失败，编译器就不会报错了，而是在运行后将错误的原因打印出来。

易错提示：
因为我们计算机的内存也是有限的，所以我们不能为所欲为的开辟空间，当我们需要开辟的空间不够时，打印错误就会出现“Not enough space”。

2、free

紧接上文，我们不能为所欲为的开辟空间，因为空间是有限的，所以应当有借有还，我们在前边向系统借用了这么多内存，当我们用完以后，我们应该把这块内存还给系统，那么怎么还呢？这里就需要用到我们的 free 函数了。

C语言为我们提供了另外一个函数，专门用来做动态内存的释放和回收的：

	void free(void *ptr)

free函数用来释放动态开辟的内存：
（1）如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的；
（2）如果参数 ptr 是NULL指针，则函数什么操作都不进行。

先来看一个例子
例4：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	// 向内存申请10个整形的空间
	int* p = (int*)malloc(10 * sizeof(int));
	// malloc -> #include<stdlib.h>

	//int* p = malloc(10 * sizeof(int));
	// 错误	 C2440	 “初始化”  :  无法从“void * ”转换为“int* ”
	if (p == NULL)
	{
		// 打印错误原因的一个方式
		printf("%s\n", strerror(errno));
		// strerror -> #include<string.h>
		// errno -> #include<errno.h>
	}
	else
	{
		// 正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	// 当动态申请的空间不再使用的时候
	// 就应该还给操作系统
	free(p);
	p = NULL;
	return 0;
}

运行结果为：
0 1 2 3 4 5 6 7 8 9

对比例3和例4，例4只是多了两行代码：
free( p );
p = NULL;

有人会疑惑了，例3和例4的运行结果明明是一样的啊，那为什么我们还要多此一举，加上这两行代码呢？
没错看上去运行结果是一样的，但这仅仅只是对于我们代码量很少的情况下，我们申请的内存够用了，所以目的达到了；但是假设我们要做一项任务量巨大的工程的时候，我们只借不还，系统的内存在不断减少，我们还能继续写程序吗？所以应该从现在养成一个习惯，申请的内存，用完以后一定要进行 free（）操作。

这里有人又有疑问了，那我们用完了内存，释放了不就好了吗？为什么还要把这个指针p置为空指针呢？
其实当我们free（p）操作结束以后，这块空间是释放了，但是p的值并没有改变，如果有人找到了这个p，进行了破坏，我们的程序就有可能出问题，所以我们不妨主动将p置为空指针，让有非分之想的人断绝这些念想。

光说不练，是学习编程语言的大忌，我们趁热打铁，来做一道练习题：

正确答案为：
例5：

#include "string.h"
#include <stdio.h>
#include<stdlib.h>
int main()
{
	char* src="hello,world"; 
	char* dest=NULL;
	int len=strlen(src);
	dest=(char*)malloc(len+1);// 要为\0分配空间
	char* d=dest;
	char* s=src+len-1;// 指向最后一个字符
	while(len--!=0){ 
		*(d++)=*(s--);// 注意不要丢掉*号
		*d ='\0';// 字符串的结尾不要忘记'\0'
	} 
	printf("%s",dest);
	free(dest);// 使用完要释放空间，避免内存泄露
	dest = NULL; // 释放不等于安全，将其置为空指针的操作不可省略
	return 0;
}

3、calloc

C语言还提供了一个函数叫 calloc ，calloc 函数也用来动态内存分配：

	void* calloc(size_t num,size_t size)

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

举个例子：
例6：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)calloc(10 ， sizeof(int));
	// calloc -> #include<stdlib.h>

	if (p == NULL)
	{
		// 打印错误原因的一个方式
		printf("%s\n", strerror(errno));
		// strerror -> #include<string.h>
		// errno -> #include<errno.h>
	}
	else
	{
		// 正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	// 当动态申请的空间不再使用的时候
	// 就应该还给操作系统
	free(p);
	p = NULL;
	return 0;
}

运行结果为：
0 0 0 0 0 0 0 0 0 0

由此可见：calloc 函数会将动态开辟空间的每个字节初始化为0

4、realloc

回归今天的核心问题，如果我们在使用内存的过程中需要对内存的大小进行调整怎么办呢？

C语言同样为我们提供了一个函数叫 realloc ，realloc 函数可以让动态内存管理更加灵活：

	void* realloc(void* ptr, size_t size);

（1）ptr 是要调整的内存地址；
（2）size 是调整后的新大小；
（3）返回值为调整之后的内存起始位置；

举个例子：
例7：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(20);
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", *(p + i));
	}
	int* p2 = (int*)realloc(p, 40);
	for (int j = 5; j < 10; j++)
	{
		*(p + j) = j;
	}
	for (int j = 5; j < 10; j++)
	{
		printf("%d ", *(p + j));
	}
	free(p);
	p = NULL;
	return 0;
}

运行结果为：
0 1 2 3 4 5 6 7 8 9

（4）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间；

（5）realloc 在调整内存空间的过程中存在两种情况
①原有空间之后有足够大的空间
此时，直接在原有内存之后追加空间，原来空间的数据不发生变化。

②原有空间之后没有足够大的空间
在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址。

图解如下：

三、常见的动态内存错误

1、对NULL指针的解引用操作

例8：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 1.对NULL指针解引用操作
	int* p = (int*)malloc(40);
	// 万一malloc失败了，p就被赋值为NULL
	// 不安全
	// 记得判断p是否为空
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;

	return 0;
}

对于例8，如果 malloc 开辟空间失败，此时 p 被赋值为NULL，而下面对于空指针进行操作， *(p + i) 始终为非法地址，我们的操作始终为非法操作，所以我们一定要在使用前记得判断p是否为空。

2、对动态开辟内存的越界访问

例9：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 2.对动态开辟内存的越界访问
	int* p = (int*)malloc(40);// 10个int -> 0-9
	if (p == NULL)
	{
		return 0;
	}
	int i = 0;
	// 越界
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

对于例9，我们使用 malloc 向系统申请了 10个int 类型，但是我们在后边访问了 11个int 类型，运行程序的时候就会出现假死的情况，虽然是动态内存，但是也是有边界的，一但越界访问，程序就会出现问题。

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

例10：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 3.对非动态开辟内存使用free释放
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
	return 0;
}

对于例10，a的空间是存放与栈区的，它并不是动态开辟的空间，free函数释放的一定是堆区上开辟的空间，如果对非动态开辟内存使用free释放，程序就会出现假死的情况。

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

例11：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 4.使用free释放动态开辟内存的一部分
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++ = i;
	}
	// 回收空间
	free(p);
	p = NULL;
	return 0;
}

对于例11，我们有这样一个操作 “*p++ = i;” ，当这个操作结束的时候，我们的指针p指向的空间已经不是我们动态开辟的完整空间了，不仅仅局限指向末尾，只要这里的p不再指向空间的初始位置，都会导致程序的崩溃。

5、对同一块动态内存的多次释放

例12：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 5.对同一块动态内存的多次释放
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	// 假设使用了空间
	// 释放
	free(p);
	// ...很多行代码过后 
	free(p);// 再次释放 
	return 0;
}

对于例12，我们在使用完空间后，释放了空间，在很多行代码过后，又释放了一次空间，这样程序同样会假死，那么我们如何改进呢？
例13：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 5.对同一块动态内存的多次释放
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	//可以这样
	free(p);
	p = NULL;
	free(p);
	return 0;
}

像例13这样，每次释放完空间，主动将p置为空指针，这样就可以有效避免了上述情况，因为我们之前提到过：
对于free函数：如果参数 ptr 是NULL指针，则free函数什么操作都不进行。

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

例14：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	// 6.动态开辟内存忘记释放（内存泄漏）
	while (1)
	{
		malloc(1);//警告	C6031	返回值被忽略 : “malloc”。
	}
	return 0;
}

对于例14，当我们开辟内存忘记释放的时候，就会造成内存泄漏。我们的电脑可能就会出现死机的情况，遇到这种情况我们一般都会重启，但是当我们写程序达到几万行的时候，出现了这种问题，那将是一个十分恐怖的事情。

四、几个经典的笔试题

1、题目1

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

请问：运行 Test 函数会有什么样的结果？
答案为：程序崩溃

对于本题，很多人的注意力会集中于 “printf(str);” ，实际上这里并没有问题，它等价于 “printf("%s\n",str);” 。

解析代码：
看到 “GetMemory(str);” ，我们在这里传递的是 str 本身的值，而不是 str 的地址，进入 GetMemory 函数以后，我们在堆上开辟了100个空间，我们将这些空间放置在 p 中，这里的 p 作为一个形参变量，在 GetMemory 函数结束以后，这个 p 就销毁了， 实际上 str 仍然是NULL，而接下来我们想要将 “hello world” copy 到 str 中去，但是 str 作为NULL，它并没有指向一个有效的空间，进行操作的时候，无法避免的进行了非法访问，虽然后边的 printf 操作没有问题，但是程序在 strcpy 操作时就已经崩溃了。

总结：
（1）运行代码程序会出现崩溃现象；
（2）程序存在内存泄漏问题：
str 以值传递的形式给 p
p 是 GetMemory 函数的形参，只在函数内有效
等 GetMemory 函数返回之后，动态开辟内存尚未释放
并且无法找到，所以会造成内存泄漏

2、题目2

“返回栈空间地址问题”

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

请问：运行 Test 函数会有什么样的结果？
答案为：随机值（或者崩溃）

解析代码：
看到 “str = GetMemory();” ，进入 GetMemory 函数的时候，p[] 这个数组是GetMemory 函数内的形参，它申请了一个空间，这个空间只在 GetMemory 函数内存在，在 GetMemory 函数结束的时候，的确将 p 的地址返回了，放置在 str 中，但是当 GetMemory 调用完成之后，p 这个数组开辟的空间返还给操作系统了，这个空间里存放的值，我们是不清楚的，接下来 “printf(str);”
打印出来的值我们不清楚，所以结果为随机值。

3、题目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);
}

请问：运行 Test 函数会有什么样的结果？
答案为：
（1）输出hello
（2）但是有内存泄漏

解析代码：
看到 “GetMemory(&str, 100);” ，将 str的地址传入 GetMemory 函数，用二级指针p 来接收，那么 *p 指向的地址即为 str ，然后将 “hello” copy 到 str 当中，再打印出来，这些操作都没有问题，但是当我们使用完 str 以后，忘记释放动态开辟的内存，导致了内存泄漏。

4、题目4

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

请问：运行 Test 函数会有什么样的结果？
答案为：
（1）world
（2）非法访问内存（篡改动态内存区的内容，后果难以预测，非常危险）

解析代码：
首先，我们向系统申请了100个字节，地址存放在 str 中；然后，我们把 “hello” copy 到 str 当中去；接下来，我们释放了这块空间，之后， str 指向的这块空间已经还给操作系统了；然后，进行判断： str 是否为空指针，虽然之前我们对申请的动态内存进行了释放，但是 str 的值并没有改变，仍然是 “hello”，所以它不为空指针；进入if语句后，将 “world” copy 到 str 当中，world 就把 hello 给覆盖了；所以打印 str 以后结果为 world。

虽然打印了world，但是这个程序依然出了问题，对于 “free(str);” 操作：已经把空间释放掉了，这表明这块空间已经不属于我们了，我们已经不能再使用这块空间了，但是接下来我们还将 world 放进去，并且打印，这就属于非法访问内存了。

提示：free（p）和p=NULL一定要连贯使用！

总结

关于动态内存分配的讲解就到此结束了，动态内存分配其实并不困难，更多的还是一些概念的背诵，只要我们牢记这些易错点，拿捏起来，还是轻轻松松的！加油，冲冲冲！
ps：动态内存分配拖了蛮久的，关于文件的博客，博主会快马加鞭的肝的（doge）