动态内存管理

徐凤年lll

已于 2023-08-12 21:27:39 修改

阅读量50

点赞数 1

分类专栏： c语言进阶文章标签： c语言 c++

于 2023-08-10 18:23:22 首次发布

本文链接：https://blog.csdn.net/m0_71920611/article/details/132206694

版权

c语言进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.malloc和free函数

void* malloc (size_t size);

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

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

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

如果参数 ptr 是NULL指针，则函数什么事都不做。

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

int main()
{
	int *ptr =(int*)malloc(40);   //整数类型的话强转成int*再使用，参数是字节
	int* p = ptr;            // 从初始地址开始释放，先把初始地址保存下来

	if (p == NULL)          //开辟失败返回空指针
	{
		perror("malloc");  //返回错误信息
		return 1;
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	//释放空间   从初始地址开始释放，先把初始地址保存下来
	free(ptr);
	ptr = NULL;

	return 0;
}


int main()
{
	int* ptr = (int*)malloc(40);   //整数类型的话强转成int*再使用

	if (ptr == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(ptr + i) = i;          //这样写的话就不会找一个临时变量了
	}
	//释放空间   从初始地址开始释放，先把初始地址保存下来
	free(ptr);
	ptr = NULL;

	return 0;
}

2.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;
   }
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
		p = NULL;

}

3.realloc函数

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

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

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

int main()
{
	int* p = (int*)malloc(40);         
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//1 2 3 4  5 6 7 8 9 10
	// 
	//如果想调整扩容到20个整形就要用realloc函数

	int* ptr=(int*)realloc(p,80);  //参数为内存地址， 调整后的大小

	//不能用p直接接收，realloc有两种情况，一种是后面内存够可以直接扩容，一种是内存不够
	//在别的地方找一块够的内存，把值放下去，把新的地址传过去，旧空间自动释放
	//如果realloc扩容失败，返回p的值是空指针，会出现问题,可以用一个临时变量 
	if (ptr != NULL)
	{
		p = ptr;
	}
	//扩容成功


	//不再使用的时候要记得free
	free(p);
	p = NULL;
	
	return 0;
    
}

4.一些常见的问题

1.对空指针解引用会造成内存访问失败的问题
解决办法对malloc的返回值进行判断

2.对动态开辟空间的越界访问
解决办法注意边界的取值范围

3对非动态开辟内存使用free释放
非动态开辟内存局部变量，系统会释放，看清楚是不是动态开辟的内存

4.使用free释放一块动态开辟内存的一部分
p要从起始地址开始释放，从后面地址开始释放就会出现这个问题

5.动态开辟内存忘记释放（内存泄漏）
忘记释放的话，系统内存就少了，造成内存泄露了，仔细检查清楚

5.常考题

1.内存泄漏

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}

p其实是str的一份临时拷贝，传的不是str的地址，传的是str本身。p里面放的是malloc开辟完空间的地址，p是形参变量，一旦出了函数就会销毁，p被系统释放了，p没了就没人记得malloc开辟空间的地址会造成内存泄漏。str里面还是空指针，空指针解引用会出现非法访问内存

正确做法

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}

传str的地址过去，用*p接收，*p里面是str的地址，把*p的地址改为malloc的地址返回去
就是str的新地址，就可以找到malloc开辟的空间

2. 返回栈空间地址的问题

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

p数组在函数内部创建是一个局部变量，出了作用域要销毁，return p是返回p的地址
当把p的地址返回去的时候，找个数组已经还给操作系统了，str此时是一个野指针，
那个地址有可能被覆盖了就会出现烫烫烫

3.野指针

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