【C语言】动态内存管理------常见错误，以及经典笔试题分析，柔性数组【图文详解】

欢迎来CILMY23的博客喔，本篇为【C语言】动态内存管理------常见错误，以及经典笔试题分析，柔性数组【图文详解】，感谢观看，支持的可以给个一键三连，点赞关注+收藏。

前言

在了解完内存操作中最关键的一节---动态内存管理，了解malloc，realloc，calloc和free的用法后，我们将继续了解动态内存管理中常见错误，以及经典笔试题的分析和柔性数组。

 上一篇博客：

【C语言】内存操作篇---动态内存管理----malloc，realloc，calloc和free的用法【图文详解】

http://t.csdnimg.cn/rYlCo

目录

一、动态内存管理常见错误

 1.1对NULL指针的解引用操作

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

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

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

1.5 对同⼀块动态内存多次释放

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

二、笔试题

2.1

2.2

2.3

2.4

三、柔性数组 

---

一、动态内存管理常见错误

 1.1对NULL指针的解引用操作

因为malloc，realloc和calloc它本身会返回地址，创建空间失败的时候会返回NULL，如果我们不对返回的地址进行检查，就可能存在free（NULL）的情况。

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));

	*p = 20;

	free(p);
	p = NULL;
}

编译器会提示警告： 

 

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

开辟出来的空间仍然要保证自己不会越界访问

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);
	p = NULL;
}

需要检查代码防止越界访问

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

int a = 10; 
int *p = &a; 
free(p);

 p并非是动态开辟出来的空间，所以是不能使用free的

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

	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (i = 0; i <5; i++)
	{
		*p = i;
		p++;
	}
	free(p);
	p = NULL;

像上述代码p并非是动态开辟的空间中的起始位置，p不再指向动态内存的起始位置 

1.5 对同⼀块动态内存多次释放

	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	free(p);
	free(p);
	p = NULL;

我的程序会触发断点，因为我对p进行了多次的释放，最好的解决办法就是是释放一次就进行置空。 

 

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

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

	if (*p == 20)
	{
		return;
	}

	free(p);
	p = NULL;
}

int main()
{
	test();
}

当运行test的时候，会提前结束函数，所以p的指向空间就未知了，但是空间还是没有释放，最后会 造成内存泄漏，切记：动态开辟的空间⼀定要释放，并且正确释放。 

二、笔试题

2.1

运行以下代码Test会有什么结果？

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}

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

程序运行结果如下：

 

 1.main中malloc申请的空间没有free

 2.strcpy对NULL解引用，导致程序崩溃

正确写法1： 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void GetMemory(char* *p)
{
	*p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}

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

 程序结果如下：

 正确写法二：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char* GetMemory()
{
	char* p = NULL;
	p = (char*)malloc(100);
	return p;
}

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

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

 结果如下：

2.2

运行以下代码Test会有什么结果？

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

程序结果如下：

 

解析：

p出了函数作用域就销毁了，哪怕str指向了字符数组，由于函数在栈区被销毁，就不会存在了，所以打印不出hello world

 

2.3

 运行以下代码Test会有什么结果？

void GetMemory(char** p, int num)
{
	* p = (char*)malloc(num);
}

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

运行结果如下：

 

解析：

没有free(str),str没有释放，会导致内存 泄漏 

2.4

运行以下代码Test会有什么结果？

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

程序结果如下： 

 

 解析：

str在free后没有置空，成为了野指针，然后我们进行拷贝，编译器会提示我们使用了未初始化的内存。这题本质上考的还是free后有没有置空。

三、柔性数组 

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

例如：

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

 有的编译器无法编译，可以改成：

typedef struct st_type
{
	int i;
	int a[];
}type_a;

3.1柔性数组的特点

结构中的柔性数组成员前面必须至少⼀个其他成员。
•    sizeof返回的这种结构大小不包括柔性数组的内存。
•    包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。 

 3.2柔性数组的使用

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 10 * sizeof(int));

	p->i = 10;
	for (i = 0; i < 10; i++)
	{
		p->a[i] = i;
	}
	//缩短数组长度
	type_a* ptr = (type_a*)realloc(p, 15 * sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
	}
	else
	{
		p = ptr;
		ptr = NULL;
	}

	free(p);
	p = NULL;
	return 0;
}

感谢各位同伴的支持，本期动态内存管理篇就讲解到这啦，如果你觉得写的不错的话，可以给个一键三连，点赞关注+收藏，若有不足，欢迎各位在评论区讨论。