本章重点（我们今天讲解的是常见的动态内存错误）

大家可以将牡蛎直接跳到常见的动态内存错误，如果对于为什么存在动态内存分配以及那几个函数还有不明白的可与i点击链接复习一下，我们正式进入到我们的正题

为什么存在动态内存分配

前面已经给大家讲过了，参见下面链接

动态内存函数的介绍

前面已经给大家讲过了
动态内存分配（1）
动态内存分配（2）

malloc

前面已经给大家讲过了，参见上面链接

free

前面已经给大家讲过了，参见上面链接

calloc

前面已经给大家讲过了，参见上面链接

realloc

前面已经给大家讲过了，参见上面链接

常见的动态内存错误

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
    
    
	int* p = (int*)malloc(40);
	//这种写代码的风格是由问题的，我们需要去判断p是否为空
	*p = 20;
	return 0;
}

原因是这里没有对p进行检测
那么正确的写法是什么呢，看下面代码

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

这种代码就是标准的动态内存开辟的代码

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

//对动态开辟内存空间的越界访问
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<errno.h>
int main()
{
    
    
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
    
    
		printf("%s\n", strerror(errno));
		return 1;
	}
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
    
    
		p[i] = i;
	}
	free(p);
	p = NULL;
	return 0;
}

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

//对非动态开辟内存空间使用free释放
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
    
    
	int a = 10;//这是栈上的内存空间，属于非内存动态内存开辟的空间使用free函数释放
	int* p = &a;
	free(p);//free释放的一定是malloc/calloc/realloc所动态开辟的内存空间
	p = NULL;
	return 0;
}

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

//使用free释放一块动态开辟内存的一部分
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
    
    
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
    
    
		return 1;

	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
    
    
		*p = i;
		p++;
	}
	free(p);
	p = NULL;
	return 0;
}

这里的p++走到最后会出整个数组，最后我们来释放p所指向的空间的时候是无法释放数组的那块空间的（或者只能释放一部分），所以这种写代码的方式是有问题的

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

//对同一块动态内存多次释放
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
    
    
	int* p = (int*)malloc(40);
	free(p);//一旦释放完p之后p就成为了野指针
	p = NULL;//这里我们一旦将p置为空指针(NULL)，第二个free(p)就没用了，这时候我们将p置为空指针，这是他就不是野指针了
	free(p);//会报错，编译器会说我一级帮你释放一次了你还让我帮你释放一次//对同一块空间的两次释放
	return 0;
}

这里的第一个free§一旦释放完空间后p就成为了野指针，这是野指针p就好比一条也够，我们需要将其拴在树上，这是我们就将其置为NULL(空指针)，这时p就不是野指针了，第二个free§也就不会继续执行了

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

这个知识点我们在动态内存分配（2）里面提及到过，大家可以再次去复习复习

//动态开辟内存忘记释放(内存泄漏)
#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
void test()
{
    
    
	int* p = (int*)malloc(100);
	int flag = 0;
	scanf_s("%d", &flag);
	if (flag == 5)
	{
    
    
		return;//...
		free(p);
		p = NULL;

	}
}


int main()
{
    
    
	test();
	//......
	return 0;
}

这里输入flag，如果真的有人输入5的话大家想一下，这里return返回，又进入到了main函数，那么我们永远都没有机会执行free，而且这块动态开辟的空间永远也找不到，没人找得到那块空间，所以这就会照成内存泄漏

//动态开辟内存忘记释放(内存泄漏)
#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
int* test()
{
    
    
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
    
    
		return p;
	}
	//....
	return p;
}


int main()
{
    
    
	int* ret = test();
	//......
	return 0;
}

我申请你释放，结果你忘记释放了，结果也会出错

忘记释放不再使用的动态开辟的空间会造成内存泄漏
切记：
动态开辟的空间一定要释放，并且正确释放
上述是我自己写的代码，我现在把代码的模板给大家
3.1 对NULL指针的解引用操作

void test()
{
    
    
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
}

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

void test()
{
    
    
 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;//当i是10的时候越界访问
 }
 free(p);
}

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

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

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

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

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

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

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

void test()
{
    
    
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
    
    
 *p = 20;
 }
}
int main()
{
    
    
 test();
 while(1);
}

几个经典的笔试题

我们下一篇博客再讲解，敬请期待

柔性数组

前面已经给大家讲过了
点击下面链接进行查看
柔性数组