常见的动态错误

对NULL指针的解引用操作

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

malloc如果开辟空间失败，就会返回空指针，所以malloc后面要加判断取消对空指针的解引用操作

正确代码:

void main()
{
	int* p = (int*)malloc(_CRT_INT_MAX / 4);
	if (NULL == p)//取消对p为NULL的解引用操作
	{
		perror("malloc");
		return 1;
	}
	*p = 20;
	free(p);
	p=NULL;
}

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

void main()
{
 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);
 p=NULL;
}

malloc总共开辟了10个int的空间，但是后面赋值的 时候访问到了第11个空间，导致越界访问

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

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

a为局部变量，放在栈区的，栈区的内存在局部运行函数结束的时候就会释放内存，free释放的应该是堆区的动态内存，否则编译器就会崩溃。

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

void main()
{
	int* p = (int*)malloc(100);
	if (NULL == p)
	{
		perror("malloc");
		return 1;
	}
	p++;
	free(p);//p不再指向动态内存的起始位置
	p = NULL;
}

free函数传入的形参必须是动态内存开辟的首地址；

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

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

对一块动态内存的多次释放也会导致编译器崩掉的。
为了避免这种情况，我们可以在free后面加一个，p=NULL，这样就会避免野指针出现了
正确代码：

void main()
{
	int* p = (int*)malloc(100);
	free(p);//释放p所指向的内存空间
	p = NULL;//将p置位空指针NULL
	free(p);//此时p=NULL，这时候编译器什么也不做
	p = NULL;
}

养成free( p )后面加上p=NULL的习惯会减少错误的出现

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

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

在test函数中首先向内存中申请了100个字节的空间，
局部变量p指向这块内存空间，但是当test（）函数运行结束时，栈区销毁，放在栈区的变量p也随之销毁，那么这100个字节的内存空间就无法找回了，找不到在哪里了除非，程序运行结束才可以释放。

这里我们可以看到程序运行到一定时间就内存就不再增加了。这是vs2019编译器对运行程序的限制，如果没有限制程序就会崩掉。
所以我们要用完动态申请的空间后要即使释放内存，也就是说malloc 与free成对出现。
下面是正确代码：

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

可以看到若没有内存泄漏，这段代码运行起来所占内存相差太大了。所以内存泄漏带来的危害是不容小觑的

几个经典的笔试题

题目一：

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

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

首先str传入到GetMemory()函数中，形参p是实参str的一份临时拷贝，所以这时候p也为NULL,接下来函数申请了100字节的空间放在了地址p所指向的位置，但是str仍为NULL，当GetMemory()函数运行结束时，指针变量p也函数GetMemery函数的销毁而销毁，但是p所指向的内存空间并没有得到释放，故存在内存泄漏。但是str仍为NULL，所以hello world写入失败。

正确修改：

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
	if (NULL == p)//取消对p为NULL的解引用操作
	{
		perror("malloc");
		return 1;
	}
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	//释放内存
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;

}

题目二：

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

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

分析：
调用GetMemory函数后返回值为p，p在GetMemery函数中代表的时数组p[]首元素的地址，并将其赋值给str。但是当GetMemory函数调用完后，栈区的空间会销毁，所以GetMemory函数的内存会销毁，以至于数组p[]的内存也随之销毁，所这时候str指向的空间并不存在，所以str为野指针，造成非法访问，输出的为随机值。

题目三：

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函数运行会有什么样的结果？

看似没啥问题，和前面第一题我们修改的代码类似。但是他使用完内存没有将内存释放，这样会造成内存泄露。
正确代码参考第一题的修改。

题目四：

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

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

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

分析：
free(str)后str所指向的空间就被释放掉了，所以此时str变成了野指针，所以str不为空指针，动态内存的空间直接被篡改并输出world。