【c语言】动态内存管理

ephemerals__

于 2024-07-06 12:08:22 发布

阅读量1.3k

点赞数 34

分类专栏： C语言文章标签： c语言开发语言

本文链接：https://blog.csdn.net/2301_80955819/article/details/140224971

版权

C语言专栏收录该内容

16 篇文章 1 订阅

订阅专栏

🌟🌟作者主页：ephemerals__

🌟🌟所属专栏：C语言

一、为什么会有动态内存管理

我们在定义一个数组的时候，这个数组的大小就是固定的，一旦确定了数组的大小，未来就不能再调整。而c语言中，提供了动态内存开辟，我们就可以自由地申请或者释放空间，更加灵活。

二、动态内存管理相关函数

1.malloc

malloc函数是c语言的库函数，使用时要引头文件stdlib.h，它用于在内存中开辟一块空间，如果开辟成功，返回值是指向这块空间的起始地址，否则返回空指针。

它的函数原型：

void* malloc(size_t size)；

注意：函数的参数是要申请的空间的大小；由于返回值是void*类型，在使用它时要进行强转。

接下来我们尝试使用这个函数：

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

int main()
{
	int* ptr = (int*)malloc(sizeof(int));
	if (ptr == NULL)//判断内存开辟是否成功，是空指针则开辟失败
	{
		perror("malloc");//打印错误信息
		return 0;//退出程序
	}
	*ptr = 1;
	printf("%d\n", *ptr);
	return 0;
}

运行结果：

2.calloc

calloc函数和malloc的作用类似，也用于开辟一块空间，区别是它开辟的空间会默认赋值为0。使用时需要引头文件stdlib.h。

函数原型：

void* calloc(size_t num,size_t size);

它所开辟的空间大小为num*size，就是num个大小为size的空间。

当然，它的使用也需要进行强转和返回值判断：

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

int main()
{
	int* ptr = (int*)calloc(3, sizeof(int));
	if (ptr == NULL)
	{
		perror("calloc");
		return 0;
	}
	return 0;
}

3.realloc

realloc可以对开辟的动态内存的大小进行调整，让我们使用内存更加灵活。

它的原型如下：

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

ptr是需要调整的空间的起始地址，size为调整后的空间大小。要注意：realloc只能对动态开辟的内存进行调整。

我们尝试使用它：

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

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

但是这样对内存空间进行调整，会有一个潜在的问题。我们仔细分析一下内存调整的过程：

realloc在对内存进行增容时有以下两种情况：

1.原有空间之后有足够大空间

此时，后面的内存空间足够增容，内存的起始地址不会变化。

2.原有空间之后没有足够的空间

此时，函数就会寻找一块更大的地方来存放原有空间和增容后的空间，但是内存的起始地址会改变。

在第二种情况下，如果内存增容失败并且我们使用原来的指针变量接收，由于返回值是空指针，这导致原有的内存空间也会丢失，真是赔了夫人又折兵。所以我们在使用realloc的时候，应该先创建一个临时变量来接收这个地址，如果它不为空指针，再赋值给指向起始地址的指针。

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr != NULL)//如果调整成功，再把接收到的地址赋值给p
	{
		p = ptr;
	}
	return 0;
}

4.free

当我们主动申请了内存空间之后，自然也需要主动释放它。而free就用于将申请的动态内存进行释放。它的原型如下：

void free(void* ptr);

其中，ptr是指向开辟内存的起始地址。注意：free只能对手动开辟的动态内存使用。

使用举例：

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

int main()
{
	//开辟动态内存
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	//使用内存空间
	for (int i = 0; i < 10; i++)
	{
		p[i] = i+1;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	//释放内存
	free(p);
	p = NULL;//及时将p制成空指针，避免野指针出现
	return 0;
}

运行结果：

三、常见动态内存开辟错误

1.对空指针解引用操作

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

int main()
{
	int* p = (int*)malloc(sizeof(int));
	*p = 1;//如果开辟失败，p是空指针，就会出问题。应该对指针的有效性进行判断
}

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

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

int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	for (int i = 0; i < 10; i++)//越界访问
	{
		p[i] = i + 1;
	}
	return 0;
}

3.对非动态开辟的内存进行free释放

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

int main()
{
	int a = 0;
	int* p = &a;
	free(p);//error
	return 0;
}

4.不完全释放开辟的内存片段

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	p++;//p已经不再指向起始地址
	free(p);
	return 0;
}

5.对同一块内存多次释放

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	free(p);
	free(p);//多次释放
	return 0;
}

6.忘记释放动态开辟的内存

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	return 0;//将导致内存泄漏
}