【c语言】动态内存分配-EW帮帮网

一、为什么要进行动态内存管理

已经掌握的内存开辟方式：

int val = 10;
char arr[10] = { 0 };

以上都是在栈上开辟内存空间
上述开辟内存空间有两个特点：

空间开辟大小是固定的；
数组在声明的时候，必须要指定数组长度，数组空间一旦确定就无法再进行调整

有时候我们需要的空间⼤⼩在程序运⾏的时候才能知道，那数组的编译时开辟空间的⽅式就不能满⾜了，因此，C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间。

二、malloc和free

2.1. malloc

void* malloc (size_t size);

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

如果开辟成功，则返回指向这一空间的指针；
如果开辟失败，返回空指针NULL，因此malloc的返回值一定要做检查；
返回值的类型为void*，所以malloc并不知道开辟空间的类型，具体使用时候要进行强制类型转换；
如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

2.2. free

free函数是专门用来对动态内存进行释放和回收的。

void free (void* ptr);//ptr指向动态开辟的空间的起始地址

如果ptr指向的空间不是动态内存开辟的，那么free函数的行为是未定义的；
如果ptr是空指针NULL，那么free什么都不做；
malloc和free都声明在 stdlib.h 头⽂件中。

2.3. 举例

开辟10个字节的空间，对其进行赋值

#include<stdlib.h>
int main()
{
	
	int* ptr = (int*)malloc(sizeof(int) * 10);//ptr指向malloc开辟的10个字节的空间
	if (ptr != NULL)//判断是否开辟成功
	{
		int i = 0;
		for (i = 0;i < 10;i++)
		{
			*(ptr + i) = i + 1;
		}
		for (i = 0;i < 10;i++)
		{
			printf("%d ", *(ptr + i));
		}
	}
	free(ptr);//用完之后要对动态开辟的空间进行释放，回收到操作系统
	ptr = NULL;//这时ptr指向的空间属于操作系统，ptr为野指针，需要置空
	return 0;

}

动态开辟的内存存储在堆上，局部变量在栈上存储，因此ptr在栈上，malloc开辟的空间在堆上。

三、calloc和realloc

3.1. calloc

void* calloc (size_t num, size_t size);

函数的功能是为num个大小为size的元素开辟一块内存空间，并把空间的每个字节初始化为0；
malloc和calloc的区别是，calloc会在返回指向这块空间的地址之前把申请的空间的每个字节初始化为0；
例如：

3.2. realloc

在开辟动态内存时，有时会发现开辟的内存过小或过大，为了合理使用内存，灵活调整大小，就可以使用realloc函数进行动态开辟的内存进行调整。

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

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

realloc在调整内存时有三种情况

情况1：

在原内存的后面有内存空间，要扩展内存直接向后追加空间，原来的内存空间不发生变化
情况2：

原内存后面的空间不够了，扩展的方法是在堆上另找一个合适大小的连续空间来使用，realloc会返回一个新的空间的地址
情况3：
调整失败，返回NULL。
因此，基于上述几种情况，使用realloc时需要进行注意：

int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//业务
	}
	else
	{
		return 1;
	}
	//扩展容量
	//代码1 直接将realloc的返回值放在ptr中
	//如果创建失败，ptr就为空了，原先开辟好的内存也无法找到
	ptr = (int*)realloc(ptr, 1000);
	//代码1，先将realloc的返回值放在另一个指针变量中，若不为空，再赋给ptr
	int* p = (int*)realloc(ptr, 1000);
	if (p != NULL)
	{
		ptr = p;
	}
	free(ptr);
	ptr = NULL;
	p = NULL;
	return 0;
}

四、常见的动态内存错误

4.1. 对NULL指针的解引用操作

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

如果malloc开辟内存失败，p为空指针，不能对其再进行解引用

4.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);
 }

这里p 指向malloc动态开辟的10个字节的空间，当i走到10的时候，访问的是第十一个字节的数据，造成越界访问

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

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

这里p并不是指向动态开辟的内存空间的地址，不能对其进行free

4.4. 使用free释放⼀块动态开辟内存的⼀部分

void test()
 {
 int *p = (int *)malloc(100);
 p++;
 free(p);
 }

这里p不再指向动态开辟内存的起始地址，free会报错

4.5. 对同⼀块动态内存多次释放

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

已经对p释放一次，不能再对其进行释放

4.6. 动态开辟内存忘记释放（内存泄漏）

void test()
 {
 	int *p = (int *)malloc(100);
	 if(NULL != p)
  	 {
    	 *p = 20;
   	}
   	//这里应该对其进行释放
 }
int main()
 {
 	test();
	while(1);
 }

调用test函数后，进入循环，如果没有对动态开辟的内存进行释放，会造成内存泄露
动态开辟的内存一定要进行释放，并要正确释放

五、动态内存经典笔试题分析

5.1. 题目1

Test函数运行后的结果是什么？

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还是空指针，对其进行解引用程序会崩溃，而且没有free，会造成内存泄漏

改正方法：应该传递的是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;
}

5.2. 题目2

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

调用GetMemory函数后，再使用str去访问数组，是非法访问，因为p数组出作用域后，这部分内存就返回给操作系统了，这时str就是野指针，打印数组后可能会打印hello word，也可能是随机值或者报错。

这个问题就像张三第一天去酒店302开了一间房，把李四要找的东西放在这了，然后告诉李四这间房现在属于我，明天可以来拿东西，但是第二天张三退房了，把302房间（内存）还给了酒店（操作系统），如果302房间被打扫了，那么李四要找的东西就不在了（返回给操作系统的内存被拿去使用了），如果侥幸302房间还没被打扫（操作系统没有用这块空间存储别的数据），那么东西还能找到（可能会打印hello word）。

5.3. 题目3

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

存在的问题是，malloc可能动态开辟内存失败，返回的是空指针NULL，就不能在对其进行字符串拷贝，同时没有进行free，可能造成内存泄漏

5.4. 题目4

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

这里动态开辟内存后，直接对其进行释放，这时str指向的空间返回给操作系统，str就是野指针，if后的内容是非法访问

六、内存区域划分

在这里插入图片描述

栈区（stack）：在执行函数时，函数内部的局部变量的存储单元都在栈区上创建，函数执行结束后这些内存单元自动释放。栈内存分配运算内置于处理器的指令集中，效率高，但分配内存容量有限。栈区主要存放运行函数而分配局部变量，函数参数，返回数据，返回地址等。
堆区（heap）：一般由程序员分配和释放，若程序员不释放，程序结束时可能会被操作系统回收，分配方式类似于链表。
数据段（静态区）：存放全局变量、静态数据，程序结束后由系统释放；
代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。

【c语言】动态内存分配

文章标题