【C语言】动态内存常见错误及经典笔试题

CSDN话题挑战赛第2期
参赛话题：学习笔记

1.动态内存常见错误

（1）对NULL指针的解引用操作

//错误
int main()
{
	int* p = (int*)malloc(20);
	*p = 5;//p是空指针，对空指针解引用是错误的

	return 0;
}

//正确
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		*p = 5;
	}
	free(p);
	p = NULL;

	return 0;
}

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

int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
		return 1;
	//使用
	for (int i = 0; i < 20; i++)
	{
		*(p + i) = i;
		//指针p只开辟了20个字节的空间，可以存放5个整型的数据
		//此时存放了20个整型的数据，进行了越界访问。
	}
   	for (int i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}

	//释放
	free(p);
	p = NULL;

	return 0;
}

• C语言允许越界访问，但这回引发不可预料的后果。

• 大家可以看这篇博客数组越界问题引出对栈区内存的探索，看出越界访问的危害只一。

• 动态内存开辟是在堆区上开辟，越界访问会对堆造成破坏，在释放或者重新分配时会导致其崩溃（如将开辟空间的内容放入文件中时，会产生断点，阻止程序继续运行）。

（3）对非动态内存使用free释放

int main()
{
	int num = 20;
	int* p = #

	free(p);
	p = NULL;

	return 0;
}

• 编译器无法实现该操作

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 0;
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*p = i;
		p++;
	}
	free(p);//释放时，p指向的已经不是动态开辟空间的起始位置。
	p = NULL;
	return 0;
}

• 编译器后爆出如下错误
  

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 0;
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p+i) = i;
	}
    
	free(p);
	free(p);
	return 0;
}

• 编译器会给出如下错误
  

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 0;
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p+i) = i;
	}
    
	free(p);
	p = NULL;//p为NULL时，free对一个空指针不继续操作
	free(p);
	return 0;
}

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

void get_memory()
{
	int* p = (int*)malloc(40);
	if (p != NULL)
		*p = 20;
}

• 指针p没有释放，当跳出此函数后，开辟的空间就无法使用，开辟的空间与程序失去联系
• 唯一的办法是等程序结束，编译器自动释放内存
  忘记释放不再使用的动态开辟的空间就会造成内存泄漏
• 动态开辟的空间一定要释放，并且正确释放

void text()
{
	while (1)
	{
		malloc(40);
	}
}

• 这个程序造成内存泄漏，一直占用内存空间。
  
• 如图所示，当该代码运行时，使用内存一直在增加（现在的编译器十分智能，到一定大小时，编译器就会停止占用内存），当程序停止时，占用内存就会被释放。

2.几个经典笔试题

题一：

void GeyMemory(char* p)//改为（char** p）
{
	p = (char*)malloc(100);//使用*p接收开辟的空间
    //判断malloc开辟空间是否成功
}
void Test(void)
{
	char* str = NULL;
	Getmemory(str);//这里需要传递指针str的地址
	strcpy(str, "Hello world");
	printf(str);
    //缺少释放、置空
}

题二：

char *GetMemory(void)
{
    char p[] = "hello world";//p是局部的数组，出函数后会自动销毁
    return p;
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();//str接收到的是被销毁了的空间，接收的是野指针
    printf(str);
}

• 代码中的字符串由数组接收，是局部变量，当函数执行完后，便会销毁
• char* p = "hello world";
• 上述代码中的字符串由指针接收，存放在文字常量区，函数执行完后不会销毁。

情况1：

int test()
{
	int a = 10;
	return a;
	//返回的值被放在了寄存器中，a的空间被释放，但寄存器中的值不会被修改
}

int main()
{
	int b = test();

	return 0;
}

情况2：

int test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* b = test();
	printf("%d",*b);
	//这里能打印，只能说明a的空间并没有被修改，但它确实被释放了，这样写代码是错误的。
	return 0;
}

int test()
{
	int a = 10;
	return &a;//返回的是栈空间的值
}

int main()
{
	int* b = test();
	printf("hehe\n");
	printf("%d", *b);
	return 0;
}

• 当在输出前，多输出一个数时，它就会改变
  

题3：

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
    //判断是否成功开辟空间
}
void Test()
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "Hello");
	printf(str);
    //存在内存泄漏
    //需要释放开辟的空间，置空指针str
}

题4：

void Test(void)
{
	char* str = (char*)malloc(100);
    //需要判断str是否为空
	strcpy(str, "hello");
	free(str);//str指向的空间已经被释放
	if (str != NULL)
	{
		strcpy(str, "world");//此时str为野指针
		printf(str);//虽然打印出来了，但所指向的空间不是我们自己的空间
	}
}