动态内存管理(1)

 

目录

为什么存在动态内存分配

动态内存函数的介绍

malloc和free

calloc

realloc

常见的动态内存错误

对NULL指针的解引用操作

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

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

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

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

动态开辟内存忘记释放(内存泄漏)


为什么存在动态内存分配

我们已经掌握的内存开辟方式有:

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

但是上述的开辟空间的方式有两个特点:

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

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

动态内存函数的介绍

malloc和free

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

void* malloc(size_t size);

 这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。

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

 

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

void free(void* ptr);

free函数用来释放动态开辟的内存。

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

malloc和free都声明在 stdlib.h 头文件中。

举个例子:

int main()
{
	//代码1
	int num = 0;
	scanf("%d", &num);
	//int arr[num] = { 0 };变长数组在当前VS2019不支持

	//代码2
	int* ptr=NULL;
	ptr = (int*)malloc(num * sizeof(int));//判断ptr是否为空
	if (NULL == ptr)
	{
		perror("malloc");
	}
	else
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			ptr[i] = i + 1;
		}
	}
	
	int i = 0;
	for (i = 0; i < num; i++)
	{
		printf("%d ", ptr[i]);
	}
	ptr = NULL;
	free(ptr);//释放ptr所指向的动态内存
	
	return 0;
}

 提示:malloc申请的空间,当程序退出时,还给操作系统,当程序不退出,动态申请的内存,不会主动释放的,需要使用free函数来释放。

calloc

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

void* calloc(size_t num,size_t size)

函数的功能是为 num 个大小为 size 的元素开辟一块空间,并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//创建成功
	//使用空间

	free(p);
	p = NULL;

	return 0;
}

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

realloc

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

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

ptr是要调整的内存地址

size调整之后的新大小

返回值为调整之后的内存起始位置

这个函数调整原内存空间大小的基础上,还会将原来内存的数据移动到新的空间。

realloc在调整内存空间存在两种情况:

        情况1:原有空间之后又足够大的空间

        情况2:原有空间之后没有足够大的空间

情况1

当是情况1的时候,要扩展内存就直接在原有内存之后直接追加空间,原来空间的数据不发生变化。

情况2

当是情况2的时候,原有空间之后没有足够多的空间,扩展的方法是:在堆空间上另找一个合适大小的连续空间来使用,这样函数返回的是一个新的内存地址。

由于上述的两种情况,realloc函数的使用就要注意一下。

举个例子:

int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//业务处理
	}
	else
	{
		perror("malloc");
	}
	//扩展容量
	//代码1

	//ptr = (int*)realloc(ptr, 100);//这样会存在风险,如果扩展容量失败,ptr会被置成NULL
								  //这样就不能找到原来ptr所指向的内容了
	int* p = NULL;
	p = realloc(ptr, 1000);
	if (p != NULL)
	{
		ptr = p;
	}
	//业务处理
	free(ptr);
	ptr = NULL;

	return 0;
}

常见的动态内存错误

对NULL指针的解引用操作

void test()
{
	int* p = (int*)malloc(INT_MAX / 4);
	*p = 20;//如果p的值是NULL,就会有问题
	free(p);
}

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

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

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

void test()
{
	int a = 10;
	int* p = &a;
	free(p);//err
}

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

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//p不再指向动态内存的起始位置
}

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

void test()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重复释放
}

动态开辟内存忘记释放(内存泄漏)

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

忘记释放内存不再使用的动态开辟的空间会造成内存泄漏。

切记:动态开辟的空间一定要释放,并且正确释放。

动态申请的内存空间,不会因为出了作用域自动销毁(还给操作系统)!

只有2种方式销毁:

1.free

2.程序结束(退出)

 

  • 10
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 5
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值