第二十一章（动态内存管理）

news2024/10/3 20:27:10

1. 为什么要有动态内存分配

2. malloc和free

3. calloc和realloc

4. 常⻅的动态内存的错误

5. 动态内存经典笔试题分析

6. 总结C/C++中程序内存区域划分

1.为什么要有动态内存管理
我们目前已经掌握的内存开辟方式有

int main()
{
	int num = 0;  //开辟4个字节
	int arr[10] = { 1,2,3,4,5,6 };
	return 0;
}

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

解决方法：
在这里插入图片描述
二、malloc和free
2.1 malloc
c语言提供了一个动态内存开辟的函数：

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

1.开辟成功，则返回一个指向开辟好空间的指针

2.开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查

3.返回类型的是void * ，所以malloc函数并不知道开辟空间的类型，具体在使用者使用的时候自己来选择

4.如果参数size为0，malloc函数的行为标准是为定义的，取决于编译器。

2.2 free
c 语言还提供了另一个函数free，是专门用来做动态内存的释放和回收的（一般是要与malloc函数同时使用的），函数原型如下
在这里插入图片描述
1.如果参数ptr指向的空间不是动态开辟的，那么free函数是为定义的
2.如果参数ptr函数是NULL的话，则函数不需要做任何事

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

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


int main()
{

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int ret = sizeof(arr) / sizeof(arr[0]);
	int* ptr = NULL;
    ptr=(int *)malloc(ret * sizeof(int));  //开辟内存
	if (ptr != NULL)
	{
		for (int i = 0; i < ret; i++)
		{
			*(ptr + i) = i;
			printf("%d ", *(ptr + i));
		}

	}
	free(ptr);  //释放内存
	ptr = NULL;  //这一步是否有必要?
	//(这里的作用是防止如果再次使用ptr进行判断，可以避免进行的访问)
	return 0;
}

这里我们来画图解释一下
在这里插入图片描述
三、calloc和recallo
除了malloc函数以外c语言还提供了另外一个函数calloc函数，calloc函数也可以用来进行动态内存的分配。原型如下：

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

int main()
{
	int* pr = (int*)calloc(10, sizeof(int));
	if(pr!=NULL)
	{
	 for (int i = 0; i < 10; i++)
	 {
		printf("%d " ,*(pr+i));
	 }
	}
	free(pr);
	pr = NULL;
	return 0;
}

在这里插入图片描述
这里我们可以知道如果我们想对申请的空间进行初始化的时候，就可以使用calloc函数来解决。

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

在有些情况下我们会发现申请的空间会过大或者过小，这时候我们就可以用realloc函数来对我们开辟内存的大小进行调整。

这里我们来解释一下
1.ptr是要调整的内存地址
2.size是调整之后新大小
注意这个函数是在原有的内存大小的基础上，将原来的数据移动到新的空间中
3.realloc在调整内存空间是存在两种情况的
3.1 原有的空间有足够大的空间情况
3.2 原有空间之后没有足够大的空间

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

情况2
当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址

由于这两种情况我们再使用realloc函数的时候就需要多注意一下

int main()
{
	int* ptr = (int*)malloc(25 * sizeof(int)); //这里是100个字节
	if (ptr != NULL)
	{
		for (int i = 0; i < 50; i++)
		{
			*ptr = i;
			printf("%d ", *ptr);
		}
	}
	//那么如果我们想要更大的内存呢？
	//int* ptr = realloc(ptr, 1000);//这种写法是有问题的，如果我们开辟了一块新的内存之后，还这样用那么可能就会导致访问的失败
	int* p = realloc(ptr, 1000);//用这种方式是最好的
	if (p != NULL) //判断如果p是不为空的话
	{
		ptr = p; // 把新地址赋给ptr，我们就可以使用ptr来操作新地址


	}
	free(ptr);
	ptr = NULL;
	return 0;

}

四、常见的动态内存的错
这里我们来举几个例子
1.

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

这个是没有判断指针是否为NULL的情况

2.越界访问

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

void test()
{
	int a = 10;
	int* pr = &a;
	*pr = 10;
	free(pr);  //对非动态内存地址进行释放
	pr = NULL;  
}

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

void test()
{
	int* p = (int*)malloc(10 * sizeof(int));
	p++;
	free(p);  //释放的位置不是起始位置
	return 0;
}



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



 void test()
 {
	 int* p = (int*)malloc(10 * sizeof(int));
	 free(p);
	 free(p);  //多次释放
	 return 0;
 }



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

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 9; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
		printf("%d ", *(p + i));
	}
	        //没有释放内存，可能会导致内存泄露
}
 int main()
 {
	 test();
	 return 0;
 }


void GetMemory(char* p)
{
	p = (char*)malloc(100);
	//没有返回值
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);//这里的函数值没有接收，所以并没有什么用
	strcpy(str, "hello world");  //所以这里的str为0
	printf(str);
}

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

该代码会报错

void Test(void)
{
	char* str = (char*)malloc(100); //这里没有判断是否为0
	strcpy(str, "hello");
	free(str);  //释放空间后没有置为0，可能就会导致内存泄露
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{

	Test();
	return 0;
}