C语言动态内存管理

🐵本篇文章将会对动态内存管理相关知识进行讲解

1. 为什么要存在动态内存管理❓

目前我们掌握了两种开辟内存的方式，分别为：

int a = 10;//存放一个值
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//存放一组数

这两种内存开辟方式都是静态的，空间上开辟的大小是固定的，a只能存放一个值，数组arr只能存放10个数，但是有时我们无法提前知道要开辟多大的内存空间，比如在通讯录程序中，我们无法事先知道要存多少人，那么接下来就来介绍动态内存管理。

2. 动态内存函数📚

2.1 malloc

malloc函数原型：

malloc的头文件是#include<stdlib.h> 参数size是要申请空间的字节大小，如malloc(10*sizeof(int));就是申请10个整形大小的空间；

malloc的返回类型是void*，意思是malloc申请完空间后并不知道这些空间是给谁申请的，所以在使用malloc函数时要强转类型，比如：int* p = (int*)malloc(10 * sizeof(int));malloc申请空间成功的话就会返回这块空间的起始地址，如果申请失败就会返回空指针，所以在使用malloc函数后要对返回值进行判断：

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

	return 0;

上述代码申请了一块很大的空间，代码的运行结果为：

由此可得，当用malloc函数申请太大空间时就会申请失败，返回空指针

一个简单的例子：

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

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

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

	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	return 0;
}

2.2 free

free函数原型

free函数是专门用来将动态内存在使用完后释放和回收的，也就是将这块申请的内存归还给操作系统，参数ptr就是我们申请的空间的起始地址；free的具体操作如下：

以int* p = (int*)malloc(10 * sizeof(int));为例

当要将这块空间释放时，要将这块空间的起始地址也就是p传给free函数，free(p)

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

free(p);

p = NULL;

对于free函数还要注意以下两点：

1.如果参数ptr指向的内存空间不是动态开辟的，free函数属于未定义行为

2.如果ptr是空指针，那free函数什么也不做

3.在申请完动态内存后如果不free的话，在程序结束后申请的空间也会被操作系统释放，但反过来如果程序不结束，申请的空间就不会被释放，所以一定要在使用完动态内存后记得用free释放空间

2.3 calloc

calloc函数原型：

calloc是用来开辟num个大小为size个字节的内存空间的，比如int* p = (int*)calloc(10, sizeof(int));就是用来开辟10个大小为4个字节的内存空间的，calloc和malloc的用法相似，但有两个区别：

1.第一个区别便是参数，同样是申请10个大小为4个字节（整形）的内存空间，这是malloc形式：int* p = (int*)malloc(10 * sizeof(int));这是calloc形式：int* p = (int*)calloc(10, sizeof(int));

2.第二个区别就是calloc在申请完空间后会将其初始化为0；

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

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	return 0;
}

打印结果：

2.4 realloc

realloc函数原型：

realloc函数作用：当原先开辟的内存空间不够时再申请一定大小的空间，也可以理解为扩容；ptr是要调整空间的起始地址，size是调整后新的大小；假如int* p = (int*)malloc(4*sizeof(int))是开辟了4个整形大小的空间，如果想再开辟2个整形大小的空间可以用int* p = (int*)realloc(6*sizeof(int));这样就又开辟了2个整形的大小；realloc的返回值是调整后内存空间的起始地址

realloc在调整内存空间时有两种情况：

1.当被调整空间之后有足够大的空间时，会直接在原空间后面追加一块空间

2.当被调整空间后面的空间不够大时，realloc函数会在堆区上另找一块空间，这块空间的大小为原空间的大小加上要增加的空间的大小，同时会将原空间的数据拷贝到新的空间

除此之外realloc还有两点需要注意：

1.realloc和malloc、calloc一样当申请成功时返回新的内存空间的起始地址，当申请失败时返回空指针

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

	p = (int*)realloc(p, 1000);
    free(p);
    p = NULL;
    return 0;
}

上述代码malloc先申请了10个整形大小的内存空间，此时p指向这块空间的起始地址，当如果下面realloc申请空间失败时，会直接将p赋为空指针，这样的话p连之前malloc申请的空间都会丢失，因此不建议这样写代码

2.realloc的第一个参数时要调整空间的起始地址，如果我们将第一个参数设为空指针的话，此时realloc函数和malloc函数的作用是等价的

3. 常见的动态内存错误❌

接下来介绍几种常见的动态内存错误，当然动态内存错误不止这几种，这里只是介绍几种较为典型的错误

3.1 错误一

没有对malloc的返回值进行判断/对NULL解引用

void test()
{
	int* p = (int*)malloc(sizeof(int));
	*p = 10; //假如p是空指针的话，这里就是对空指针解引用

	free(p);
	p = NULL;
}

3.2 错误二

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

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

	int i = 0;
	for (i = 0; i <= 10; i++);
	{
		p[i] = i; //当i=10时，越界访问
	}

	free(p);
	p = NULL;
}

3.3 错误三

对非动态开辟的内存空间进行free释放

void test()
{
	int a = 10;
	int* p = &a;

	free(p); //p保存的是非动态开辟的内存
	p = NULL;
}

3.4 错误四

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

void test()
{
	int* p = (int*)malloc(4 * sizeof(int));
	p++;

	free(p); //此时p不再指向动态开辟的内存的起始地址
    p = NULL;
}

3.5 错误五

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

void test()
{
	int* p = (int*)malloc(4 * sizeof(int));
	
	free(p);
	free(p);
    p = NULL;
}

3.6 错误六

忘记释放动态开辟的内存空间

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

int main()
{
	test();

	whlie(1); //这里只是模拟了一个不会自动停止的程序
	return 0;
}

这些错误看似简单，但在初学者学习时总是会不经意的犯这些错，所以在使用动态开辟的内存时一定要注意

4. 经典笔试题✍🏻

4.1 题目一

	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函数（传值调用）在GetMemory中由指针p接收，然后通过malloc开辟了100个字节，但是形参只是实参的一份临时拷贝，所以为p开辟了100个字节并不影响str，str仍旧是空指针，GetMemory使用完后在strcpy中将"hello world"拷贝到str，这涉及到了对NULL的解引用，因此程序会报错

【修改】可以将str的地址传给GetMemory，之后GetMemory可以用一个二级指针接收

4.2 题目二

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

【解析】在Test中，str接收GetMemory的返回值，在GetMemory中创建了数组p，之后将数组的首元素地址返回，此时str所保存的就是数组p的首元素地址，但是GetMemory使用完后空间被释放，数组p的空间不再是我们自己开辟的，在printf中通过str打印"hello world"会涉及到指针访问不是我们开辟的空间（野指针），因此打印结果会是乱码

【修改】可以在GetMemory中用malloc为数组p开辟空间，因为动态开辟的空间如果程序不结束或不用free函数，这块空间就不会释放；也可以用static修饰数组p

4.3 题目三

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中，将str的地址传给了GetMemory，之后GetMemory用二级指针接收，随后用malloc开辟了100个字节，回到Test函数通过strcpy将"hello"拷贝到str，打印结果也就是hello，整个程序没有问题

4.4 题目四

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

【解析】malloc为str开辟了100个字节的空间，之后free将这份空间释放，此时str仍然保存着这块空间的地址，在if的条件判断中为真，在strcpy中要将world拷贝到str所指向的被释放的内存空间中，这也就涉及到了非法访问（野指针）

🙉动态内存管理至此讲解完毕，接下来会对文件相关内容进行讲解