动态内存管理(上)

为什么要有动态内存分配

在学动态内存分布时我们先了解一下内存的一点知识
在这里插入图片描述
内存是分栈区,堆区和静态区

我们已经掌握的内存开辟⽅式有
int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的方式有两个特点：
• 空间开辟大小是固定的。
• 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整

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

而如果我们一次性就开辟很大的空间,比如我只明明只需要开辟4个字节的空间,而最后却开辟了100个字节的空间,那么多出来的空间就浪费掉了

因此C语言引人了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。(注意必须最后要释放,如果只申请不释放的话内存会越来越大)

malloc和free

malloc

C语言提供了一个动态内存开辟的函数malloc:

void* malloc (size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间起始地址的指针。
• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查(用perror(“malloc”)来检查)。
• 返回值的类型是 void ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定*。
• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
什么情况会使内存开辟失败呢?
来看看下面的一个代码

#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(INT_MAX*10);
	if (p == NULL)
	{
	perror("malloc");
		return 1;//非0表示异常返回
	}
	return 0;//0表示正常返回
}

INT_MAX是整形的最大值,他的值如图
在这里插入图片描述
在我们还没有运行的时候系统就已经报错了

我们再看看perror输出的结果

在这里插入图片描述
显然我们开辟的空间过大,导致没有了足够的空间

如果我们申请0个字节会怎么样
在这里插入图片描述
并没有报错
那我们再申请-1个字节又会怎么样

我们可以看到输出的结果是没有足够的空间

我们再看一个代码

#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	return 0;

}

在这里插入图片描述
这里的p指向malloc开辟的起始地址,由于内存中存放的都是int类型的元素,那么p+i就表示p跳过i个元素,对其解引用就是内存中的具体值,这里就非常像数组

free

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下

void free (void* ptr);

free函数用来释放动态开辟的内存。
• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。
malloc和free都声明在 stdlib.h 头文件中。
在之前有提到,每次都要释放内存,而在malloc的代码中却没有释放,这里需要解释一下

#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	return 0;

}

由于这个程序是运行完了的,所以系统会自动回收内存,因此并不需要我们主动去回收(当然了主动回收也是一个好习惯),而有些程序是一直运行的,或者会运行很久,这样导致开辟的空间一直没有释放,而在运行的过程中不断的开辟新的内存空间,导致内存越来越大,所以需要自己去主动释放内存

最后结论就是如果程序运行完,就会自己回收内存空间,这是被动回收
而用free回收的话,就是可以在程序还没有运行完就可以回收,这是主动回收

举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	int arr[num] = { 0 };
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	} 
	free(ptr);
	ptr = NULL;
	return 0;
}

在这里插入图片描述
这里free时我们只是回收了arr的内存空间,但是ptr却仍然保存着arr的地址,因此在最后我们需要让ptr==NULL变成空指针,否则就会变成野指针

calloc和realloc

calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0
举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));//10表示申请多少个元素,sizeof(int)表示申请一个元素有多大
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述
由于calloc初始化,使空间中的元素全为0,所以输出的结果都是0

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述
malloc没有初始话,导致输出的结果就是这样

所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务

realloc

realloc函数的出现让动态内存管理更加灵活。

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们⼀定会对内存的大小做灵活的调整。

那 realloc 函数就可以做到对动态开辟内存大小的调整。

函数原型如下

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

•ptr 是要调整的内存地址
• size 调整之后新大小
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
• realloc在调整内存空间的是存在两种情况：
◦ 情况1：原有空间之后有足够大的空间
◦ 情况2：原有空间之后没有足够大的空间

情况1
当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
在这里插入图片描述

情况2
当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小
的连续空间来使用。这样函数返回的是一个新的内存地址。
在这里插入图片描述
我们具体举个例子

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* ptr = (int*)malloc(100 * sizeof(int));
	//扩展容量 
	int* p = NULL;
	p = realloc(ptr, 10000 * sizeof(int));
		ptr = p;
	free(ptr);
	return 0;
}

在这里插入图片描述

显然这里的realloc是重新找了一块新的内存空间,并返回的

因此由于上述的两种情况，realloc函数的使用就要注意⼀些。

//代码1 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//业务处理
	} 
	else
	{
	return 1;
	} 
	//扩展容量
		ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)	
		free(ptr);
	return 0;
}

//代码2
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* ptr = (int*)malloc(100*sizeof(int));
	if (ptr != NULL)
	{
		//业务处理
	} 
	else
	{
	return 1;
	} 
	//扩展容量 
	int* p = NULL;
	p = realloc(ptr, 1000*sizeof(int));
	if (p != NULL)
	{
		ptr = p;
	} 
		free(ptr);
	return 0;
}

代码一和代码二的区别就在于一个是直接用ptr接收realloc的返回值
一个是判断realloc的返回值是否为空
为什么需要判断返回值是否为空呢?

如果返回值为空,那么让ptr等于空指针的话,之前内存所保存的所有元素都被消失(也可以说是之前申请的内存都没有了,当然就没有保存的元素了)

而如果判断返回值不为空之后,再将返回值传给ptr,那么内存保存的所以元素都不会消失

此外realloc还可以当成malloc使用

#include<stdio.h>
int main()
{
	realloc(NULL,sizeof(int))//==malloc(1*sizeof(int))
	return 0;
}