【C学习】动态内存管理：动态内存函数（malloc、calloc、realloc、free），动态内存分配的常见错误。含经典笔试原题！！

---

为什么需要动态内存管理？

通常我们的内存开辟方式如下：

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

上述的开辟空间的方式有两个特点：

空间开辟大小是固定的。

数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。
动态开辟可以满足我们对申请空间大小的掌控。

---

一、动态内存函数

如上述举例，这些变量通常是被储存在栈上，会被某个域限制生命周期，出了域就自动销毁

通过动态开辟的内存，是储存在堆上的，如果不由用户主动定义销毁，则只能等程序结束时才会被自动销毁。

1.1 malloc 和 free

🧩 void* malloc (size_t size)

描述：以字节为单位申请一块连续内存，返回一个指向这块内存开始的指针

返回值：void* 类型的指针， 若要使用，需要强制类型转换一下，如果内存申请失败，返回空指针
（需要检查一下是否 malloc 成功，一是为了程序安全，二是如果不检查有的编译器会报错，写法详见代码）

参数：需要开辟空间的大小， 以字节为单位

包含头文件： <stdlib.h>

🙋‍🌰举个栗子：

// INT_MAX 有符号整形的最大值，可以用于测试申请空间失败
int main()
{
	// 申请
	//void* p = malloc(40);		// void* 没法直接用 
	int* p = (int*)malloc(40);
	int* ptr = p;
	assert(p);					// 暴力检查 <assert.h>
	
	// 使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*ptr = i;
		ptr++;	
	}

	// 释放
	free(p);	// 把 p 指针指向的，连续开辟出的空间释放了。但此时 p 指针还指向这块空间！
	p = NULL;	// 让 p 指向“空”，避免非法访问~
	ptr = NULL;

	return 0;
}

（malloc 的成功性检查还能这样写

#include <errno.h>	// errno
#include <string.h>	// strerror

...
if (p == NULL)
{
	printf("%s\n", strerror(errno));
	return 1;
}

if (p == NULL)
{
	perror("malloc fail");
	exit(-1);
}

🧩 void free (void* ptr)

描述：释放先前由 malloc、calloc、realloc 开辟或分配的空间，使这块空间可以接着被使用

参数：需要释放的空间地址， 必须指向被开辟空间的开始位置

包含头文件： <stdlib.h>

注意：malloc 后必 free、calloc 后必 free，这两对一定要 在一每段运行逻辑中 成对出现，防止内存泄漏！借了还得还啊~~

对于 free()，不是只要在末尾出现了就一定安全，要看程序的执行逻辑。

🙋‍🌰举个错误使用的栗子：

int test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		...
		return 1;
	}

	// ...使用...
	if (a == 2)
		return 2;	// 没有 free 直接返回了，内存泄露
	if (a == 3)
	{
		free(p);
		p = NULL;
		return 3;	// 这样才正确~~~~
	}	

	//释放
	free(p);
	p = NULL;
	return 0;
}

---

1.2 calloc

🧩 void* calloc (size_t num, size_t size)

描述：给数组申请一块空间，将每个元素初始化为 0，然后返回指向这块内存开始的指针

返回值：void* 类型的指针， 若要使用，需要强制类型转换一下，如果内存申请失败，返回空指针
（需要检查一下是否 calloc 成功）

参数 num：需要申请空间的数组的 元素个数

参数 size：每个元素的大小

包含头文件： <stdlib.h>

助记：calloc = malloc + memset

🙋‍🌰举个栗子：

// 若我们向内存申请 40 个字节，打算存放 10 个整型

int main()
{
	// 申请
	int* p = (int*)calloc(10, sizeof(int));
	
	// 使用
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

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

	return 0;
}

在上述案例的使用过程中我们不难发现 calloc = malloc + memset

实际使用中，malloc 少了一步初始化效率自然更高，一般如果有需要初始化为 0 可以考虑用 calloc。

---

1.3 realloc

🧩 void* realloc (void* ptr, size_t size)

描述：改变指针指向空间的大小

返回值：void* 类型的指针， 可以根据使用者需求进行 类型转换，如果内存申请失败，返回空指针 （需要检查一下是否 realloc 成功）

参数 ptr：一个指针，指向需要改变的空间最开始， 如果传空指针，则此时等价于 malloc

参数 size：所需要的空间大小，单位为字节

包含头文件： <stdlib.h>

int main()
{
	// 申请
	int* p = (int*)malloc(40);
	assert(p);

	// 使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	// 增加空间
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
	else
	{
		printf("%s\n", strerror(errno));
		return 1;
	}

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

	return 0;
}

realloc 对旧空间调整时的两种情况：

原空间后面空间足够让 realloc 进行扩容，如果成功，返回的还是原来的地址

原空间后面空间不够，realloc 会找一块新的，大小为申请大小的空间，然后拷贝原空间里的数据到新地址，再 free 掉原空间里的内容，最后返回新的地址。

二、动态内存分配的常见错误

1. 对空指针的解引用操作❌

int main_err()
{
	int* p = (int*)malloc(40);
	*p = 5;	// err.
			// 修改：检查返回值

	return 0;
}

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

int main_err()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
		return 1;

	for (int i = 0; i < 5; i++)
	{
		//*(p + i) = i;
		p[i] = i;	// 编译器能查出来
	}

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

3. 对非动态开辟空间的释放❌

int main_err()
{
	int num = 10;
	int* p = #

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

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

int main_err()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
		return 1;

	for (int i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}

	//释放的时候，p不在指向动态空间的起始位置 
	free(p);
	p = NULL;
	return 0;
}

5. 对同一块动态内存多次释放❌
6. 动态开辟内存忘记释放（内存泄露）❌

int* getmemory()
{
	int* p = (int*)malloc(40);
		//...这里如果不释放，应该声明，让使用者知道，这里面有动态开辟的内存需要使用者自行释放
	return p;
}

int main_err()
{
	int* ptr = getmemory();

	// 应该在此处释放
	return;
}

三、🚩经典笔试题

【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：GetMemory() 后 str 仍然为空，空指针指向的地方是没办法被覆盖的
 解决1：传二级指针（更优），或者传返回值（一般哦）
 问题2：malloc 未检查，未 free() 导致内存泄漏

【2】

// 运行 Test 函数会产生什么结果？		输出乱码
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

------------
 问题：返回了栈空间的地址。
        GetMemory() 里创建的数组，出了函数就销毁了，虽然返回了地址但里面的内容可能已经被别的程序用了

【3】

// 运行 Test 函数会产生什么结果？      打印出hello
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 在这
}

------------
问题：内存泄漏

【4】

// 运行 Test 函数会产生什么结果？		非法访问
void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

------------
问题：if 里面的 str 非法访问