C语言编程动态内存分配常见错误全面分析

目录

• 前言：为什么存在动态内存分配？
• 一、动态内存函数
• 1.malloc和free函数
• 2.calloc函数
• 3.realloc函数
• 二、常见错误
• 1.对NULL指针解引用
• 2.对动态开辟空间的越界访问
• 3.对非动态开辟使用free函数
• 4.使用free释放一块动态内存开辟内存的一部分
• 5.对同一块空间多次释放
• 6.动态开辟内存忘记释放
• 总结

前言：为什么存在动态内存分配？

我们已经掌握的内存开辟方式如下

int a=10;//在栈空间上开辟4字节
char arr[10]={0};//在栈空间上开辟10字节连续空间

以上开辟空间的方法有两个缺点：
1.空间开辟的大小是固定的。
2.数组在声明的时候，必须指定数组长度，它所需要的内存在编译时进行分配。
但是对于空间的需求，不仅仅是上述的情况。有时我们需要的空间大小在程序运行时才能知道，这时上述的方法就不能满足需要了，我们来介绍一种解决方案：动态内存分配

一、动态内存函数

（图片来自比特就业课）

计算机在使用时会有三个区：常见的有栈区——用来存放局部变量、函数形式参数；静态区——用来存放静态区和全局变量；最后一个堆区则是我们用来动态内存分配的，学习动态内存分配必须掌握以下4种函数：

1.malloc和free函数

malloc函数声明：

void*malloc(size_t size);//size_t即unsigned int

该函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。注意点如下：
1.如果开辟成功，返回一个指向开辟空间的指针
2.如果开辟失败，返回一个NULL指针
（由于是NULL指针，所以对于malloc函数常用assert进行检查）
3.返回值类型为void*,所以malloc函数开辟空间的类型需要使用者自己进行决定
4.如果size=0，malloc的行为取决具体编译器

free函数声明

void free(void*ptr);

free函数用来释放动态开辟的空间，注意点如下：
1.如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未知的
2.如果ptr是空指针，free函数什么也不做
实战举例：

#include<stdio.h>
#include<stdlib.h>//malloc和free函数头文件
int main()
{
	int*p=(int*)malloc(40);//malloc出来的空间是不确定类型的，需要你自己强转一个类型
	//这里我们把它转换成int*,由整型指针对这块空间进行维护
	//那这里会是4个字节看成一个元素,40个字节，可填充10个int元素
	if (p == NULL)
	{
		return -1;
	}//如果没有返回值则说明开辟成功
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		*(p + i)=i;//对开辟空间进行赋值操作
	}
	free(p);//用完之后不需要了，用free函数释放p所指向的空间（40个字节全部释放掉，还给操作系统）
	p = NULL;//由于p存储的是开辟空间的地址，即使空间还给了操作形态，但p还是可以找到这块空间，这是非常危险的，所以我们用一个空指针赋给p
	return 0;
}

2.calloc函数

calloc函数也是用来动态内存分配的，函数声明如下

void*calloc(size_t num,size_t size)

该函数功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节都初始化为0
它与malloc函数的区别只是在返回地址前会把申请空间里的每个字节都初始化为0

代码如下（示例）：

#include<stdio.h>
#include<stdlib.h>//calloc函数头文件
#include<string.h>//strerror函数头文件
#include<errno.h>//errno头文件
int main()
{
	int*p = (int*)calloc(10, sizeof(int));//开辟10个大小为int型的空间
	if (p == NULL)//calloc函数也有可能开辟空间失败，需要进行检验
	{
		printf("%s\n", strerror(errno));//errno是错误码，strerror会把错误码转换成相应的错误信息
		return -1;
	}
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		printf("%d ", *(p + i));//会打印10个0（calloc会自己初始化为0）
	}
	free(p);
	p = NULL;
	return 0;
}

3.realloc函数

realloc函数是在已有空间不够的情况下，进行追加申请空间的函数，其声明如下：

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

realloc函数是为了让动态内存管理更加灵活，有时候我们发现之前申请的空间过少了，或者过大了，我们可以用realloc函数来进行增减，它的注意点如下：
1.ptr是要调整的内存地址
2.size是调整之后新的大小
3.返回值是调整后的内存起始位置
4.该函数在调整原先内存大小的基础上，还会将原来内存的数据复制到新空间
5.realloc函数在调整内存空间存在两种情况
关于4和5解释如下：
假设我们现在追加1倍空间

第一种：如上图，红色是我们开辟的空间，蓝色是其他程序正在使用的空间，又因为我们要开辟空间肯定是物理上连续的，我们又不能使用蓝色部分，中间的空白空间又完全不够原先空间的两倍，那怎么办？

我们会另外找一块足够空间的地方进行原空间两倍的开辟，并且把原空间内数据进行复制到新空间，函数返回新空间的地址。

第二种：这种就比较简单了，原先空间后面就足够追加开辟一块1倍的空间，我们直接进行开辟即可。

函数直接会返回原先空间的首地址。
当然了，realloc函数同malloc和calloc函数一样，也有可能开辟空间失败，所以依然需要检验是否返回的是空指针

#include<stdio.h>
#include<stdlib.h>//malloc和free函数头文件
int main()
{
	int*p=(int*)malloc(40);//开辟10个int大小的空间
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		*(p + i)=i;//对开辟空间进行赋值操作
	}
	int*ptr = realloc(p, 20 * sizeof(int));//注意！这里20*sizeof（int）是新的大小
	//比如我现在只有10个，我需要20个，差10个。但这里不是写10，而是写新的大小20
	if (ptr != NULL)
	{
		p = ptr;
	}
	for (i = 10;i < 20;i++)//对新开辟空间赋值
	{
		*(p + i) = i;
	}
	for (i = 0;i < 20;i++)
	{
		printf("%d ", *(p + i));//打印0-19
	}
	free(p);
	p = NULL;
	return 0;
}

二、常见错误

1.对NULL指针解引用

代码如下（示例）：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(20);
	*p = 0;//对p这个地址解引用并赋值为0
	free(p);
	return 0;
}

malloc等等函数在开辟空间时都是有可能开辟失败的，万一失败，就是返回空指针，你直接对空指针解引用并赋值肯定是有问题的

所以我们这里还是要进行指针检验
代码如下（示例）：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(20);
	if(p==NULL)
	{
	return -1;
	//如果返回，开辟失败结束程序，如果没有返回则可进行下面的操作
	}
	*p = 0;//对p这个地址解引用并赋值为0
	free(p);
	return 0;
}

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

代码如下（示例）：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(200);//200个字节也就是50个int型
	if (p == NULL)
	{
		return -1;
	}
	int i = 0;
	for (i = 0;i < 60;i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

这个代码乍一看上去没有问题，但是仔细看的话就会发现端倪，malloc开辟200字节空间也就是50个int型，你for循环赋值最多循环次数也只能是50次啊，你循环60次肯定是越界访问了，这里也是妥妥的会报错。

3.对非动态开辟使用free函数

代码如下（示例）：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a = 10;
	int*p = &a;
	free(p);
	p = NULL;
}

我们这里int创建了a，然后把a的地址赋给了int*类型的p，再然后free掉p。这种操作也是铁定会报错的，p这个局部变量是在栈上的，而free函数针对的是堆区

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

代码如下（示例）：

//使用free释放一块动态内存开辟内存的一部分
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return -1;
	}
	//使用
	int i = 0;
	for (i = 0;i < 5;i++)
	{
		*p++ = i;
	}
	//释放
	free(p);
	p = NULL;
}

这里的代码有什么问题呢？我们画一个图就一目了然了

一开始p在上图位置，然而随着for循环，p++这个操作，p指向的位置不断往后，一直到下图位置

这时p已经不指向原先开辟空间的位置了，你这时候去用free释放掉显然是不合适的

5.对同一块空间多次释放

我们先来看2段代码：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}
	free(p);
	free(p);
}

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}
	free(p);
	p = NULL;
	free(p);
}

两段代码都是对同一块空间多次释放，但第一段代码会报错，第二段不会。
解释如下：
第一段代码你已经释放掉p所指向的空间了，空间里什么也没有了，但p仍然指向那块空间，所以你再次释放不属于你的空间肯定会报错。
第二段代码你释放掉p所指向空间，然后用空指针给p赋值，再去释放空指针，我们知道，free空指针是什么也不做，所以不会报错。

6.动态开辟内存忘记释放

对于动态开辟内存忘记释放，在堆区上申请的空间有2种回收方式：
1.你自己free掉
2.程序退出时，系统自动回收
我们先来看一段代码

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int*p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}
	getchar();
	return 0;
}

该代码我们没有自己使用free来释放内存，而中间又有getchar一直在等待接收字符，打个比方：假如你中途去上厕所或者干其他事情了，getchar一直没有接收到字符，程序就一直没有结束，那我们用p开辟的空间在你上厕所期间就一直被占用，那块空间系统没办法去做别的有意义的事情。而上升到将来公司层面：我们写的程序可能一天24h都在跑，那遇到这种情况，你没有free掉内存，你不用又不回收，整体效率的影响是非常大的。

总结

今天介绍了动态内存分配函数和一些常见的动态内存分配的错误，希望读者学习有所收获，祝读者学业有成，万事顺心！

更多关于C语言动态内存分配的资料请关注我们其它相关文章！