解密C语言动态内存管理：让你的程序实现优化升级

这里是图片：

前言

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

int a = 10;//固定的向内存申请4个字节
int arr [10];//申请连续的一块空间
//缺点：一旦空间申请完毕就不能在修改空间大小

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

1. 空间开辟大小是固定的。
2. 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

那么C语言中能不能有一种方式让我们来申请空间，空间不足时可以增加，空间过大时可以减小？这时就出现了动态内存管理。

1.动态内存函数介绍

1.1 malloc

我们今天要学的函数都是针对堆区的。

malloc： 用来申请一块内存空间。

malloc：
申请一块大小为size个字节的内存块，然后返回一个指针，指向这个块的起始地址。
因为不知道未来这个内存会放什么类型的数据，所以返回类型为：void*
如果内存申请失败，将返回一个空指针。

malloc函数的使用：

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

int main()
{
	//申请40个字节（连续的空间），未来存放10个整形
	int* p = (int*)malloc(40);//因为已经知道存放的类型为int所以直接转换成int*的指针接收返回值
	//注：有可能开辟空间失败
	//开辟失败
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));//如果开辟失败，生成失败原因
		return 1;
	}
	//开辟成功
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

上述代码还存在一定的问题，因为我们在堆区上申请的空间，还的时候也需要亲自还一下（如果不还，在程序运行结束时空间也会被操作系统回收），但是这个程序如果一直不结束，又不主动归还空间，那么就会导致这块空间一直被占用。
所以当这块空间不使用的时候我们需要主动归还这块空间。

1.2 free

free: 是释放申请的内存

ptr – 指针指向一个要释放内存的内存块

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

free(p);
p = NULL;//因为free执行并不会把p置为空指针，所以我们需要手动置为NULL

在上述代码中加入此句就可以释放内存空间。
空间释放前：

空间释放后（未置p为NULL）：

如果不手动置为NULL，如果之后再访问p就会出现非法访问

空间释放（手动将p置为NULL）：

空间申请失败：
其实空间也会有申请失败的时候的，比如我们试着申请INT_MAX

int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));//如果开辟失败，生成失败原因
		return 1;
	}
	return 0;
} 

运行效果：

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
malloc和free都声明在 stdlib.h 头文件中。

1.3 calloc

calloc和malloc是有所差异的
num – 要被分配的元素个数。
size – 元素的大小。
开辟num个大小为size的空间。

calloc函数的使用：

int main()
{
	//malloc,calloc 都是在堆区上申请空间
	//空间使用完都要释放

	int* p = (int*)calloc(10, sizeof(int));
	//calloc也有可能开辟空间失败
	//开辟失败也会返回空指针
	if (NULL == p)
	{
		perror("calloc");//如果失败，打印失败原因
		return 1;
	}
	//开辟成功
	//使用
	int i = 0;
	for (i = 0; i < 10;i++)
	{
		printf("%d ", * (p + i));
	}
	
	//使用完后释放
	free(p);
	p = NULL;

	return 0;
} 

运行效果：

malloc和calloc的区别：
malloc申请到的空间，没有初始化，直接返回起始地址。
calloc申请好空间后，会把空间初始化为0，然后返回起始地址。
如果我们不希望申请到的空间被初始化，可以使用malloc，希望被初始化就用calloc

1.4 realloc

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

realloc：尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。

ptr – 指针指向一个要重新分配内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针，则会分配一个新的内存块，且函数返回一个指向它的指针。
size – 内存块的新的大小，以字节为单位。如果大小为 0，且 ptr 指向一个已存在的内存块，则 ptr 所指向的内存块会被释放，并返回一个空指针。

realloc函数的使用：

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

int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc");
		return 1;
	}
	//开辟成功
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
	//空间不够，增加10个整形的空间
	//调整
	int* ptr = (int*)realloc(p, 10 * sizeof(int));//临时指针接收
	//防止扩容失败p指向的内容丢失
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;//防止出现野指针
	}
	//继续使用
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//使用完，释放空间
	free(p);
	p = NULL;

	return 0;
} 

realloc在调整内存空间的是存在两种情况：

realloc扩容失败时，会返回NULL，如果不用新指针(ptr)接收，万一扩容失败，p就会被置为NULL。
所以我们最好创建一个新的指针来接收他的返回值。

返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

realloc传递空指针

int main()
{
	//当传递NULL时其功能和malloc一致
	int* p = (int*)realloc(NULL, 40);// = malloc(40);
	return 0;
} 

2.常见的动态内存错误

2.1 对NULL指针的解引用操作

我们来看以下代码：

int main()
{
	int* p = (int*)malloc(100);//正常情况需要判断指针是否为空
	//未判断直接使用
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p + i) = 0;
	}

	return 0;
}

这种写法其实是非常危险的，如果malloc函数开辟空间失败了，那么p就是一个野指针（NULL），所以malloc的返回值一定要判断。

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

动态开辟的空间也是一块连续的空间，所以在访问的时候也是有可能出现越界访问的。

int main()
{
	int* p = (int*)malloc(100);
	//开辟了100个字节(25个整形)
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	//访问了100个整形
	//越界访问
	for (i = 0; i < 100; i++)
	{
		p[i] = 0;
	}
	free(p);
	p = NULL;

	return 0;
}

编译器也会报出相应的警告，所以一定要注意编译器上的警告，不要出现越界访问的现象。

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

int main()
{
	int a = 10;//栈区
	int* p = &a;

	free(p);
	p = NULL;

	return 0;
}

free释放的是堆区上的空间，但是p指向的空间是栈区上的，当我们这样去运行代码的时候这个程序就会挂掉。

所以我们在使用free的时候要注意，不能对非动态开辟的空间使用。

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

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 25; i++)
	{
		*p = i;
		p++;
	}
	//使用完释放
	free(p);//p不再指向动态内存的起始位置
	p = NULL;

	return 0;
}

这段代码，当我们使用完空间进行释放的时候，想想p指针还指向原来的位置吗。

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

如果我们释放已经被释放的内存空间，那么这时的程序也是会有问题的。

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	//使用
	//释放
	free(p);
	//p未置空指针，为野指针
	//释放后在进行释放
	free(p);

	return 0;
}

如果运行这段代码我们的程序最后也会挂掉。

但是如果我们在第一次释放内存空间的时候把p设置成NULL，这时我们的代码就不会出现任何问题了。
如下：

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	//使用
	//释放
	free(p);
	p = NULL;
	//释放后在进行释放
	free(p);

	return 0;
}

所以我们一定要记得，在free使用完之后一定要把指针置为空指针。

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

void test()
{
	int* p = (int*)malloc(100);
	//使用
	//使用完后未进行释放
}
int main()
{
	test();
	//函数调用结束之后，p指针将被销毁，那么这100个字节就会出现无法释放的问题
	//只有当程序结束/挂掉时，内存才会释放
	return 0;
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记：
动态开辟的空间一定要释放，并且正确释放。

注意一些使用问题：

void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return;
	}
	//使用
	//假设某个条件被满足
	if (1)
	{
		return;//程序提前结束
	}
	//释放
	free(p);
	p = NULL;
}

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

这段代码中虽然有free，但是程序运行的过程中提前结束了，没有进行释放操作，这也会导致内存的泄露。
所以在设计代码的时候需要注意这种情况。

以上就是本篇文章的全部内容了，希望大家看完能有所收获。