C语言-动态内存分配

愿天垂怜2024-04-28 10:38

即使行动导致错误，却也带来了学习与成长;不行动则是停滞与萎缩。💓💓💓

•🌙知识回顾

亲爱的友友们大家好！💖💖💖，我们紧接着要进入一个新的内容，就是动态内存的管理与分配，**上两篇文章我们详细解析了C语言中的自定义类型，包括结构、联合和枚举，**希望大家能够掌握并应用~

今天这篇文章给大家带来的是C语言中动态内存分配的知识，这是后面我们学习数据结构经常用到的，必须熟练掌握，希望大家好好学习，为后续数据结构打下基础，也希望可以给大家带来帮助。

👇👇👇

💘💘💘知识连线时刻（直接点击即可）

🎉🎉🎉复习回顾🎉🎉🎉

自定义类型结构体详细讲解

自定义类型联合和枚举讲解超详细

博主主页传送门：愿天垂怜的博客

🍋知识点一：为什么要有动态内存分配

我们学习了这么久的C语言，也掌握了开辟空间的方式有：

cpp 复制代码 
	int a = 10;//在栈空间开辟了4个字节
	char arr[10] = { 0 };//在栈空间开辟了10个字节的连续空间

但是上面的两种开辟空间的方式有两个特点：

🔥空间开辟大小是固定的。

🔥数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整。

比如我需要描述一个班级学生的数学成绩，我创建了一个有30的元素的数组 int math[30] ，看似没什么问题，但是数组空间已经不能更改了，如果班级人数为35人，那这个数组就不够了，如果班级是20个人，空间又多余了，容易造成浪费。

所以对于空间的需求，不仅仅是固定不变的。有时候我们需要的空间大小在程序运行的时候才能知道，那数组编译时开辟空间的方式就不能满足了。

由此，C语言引入了动态内存的开辟，让程序员可以自己申请和释放内存，就比较灵活了。

而动态内存开辟包括三个部分：申请、使用、释放。

🍋知识点二：malloc和free

• 🌰1.malloc

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

cpp 复制代码 
void* malloc (size_t size);

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

🔥如果开辟成功，则返回一个指向开辟好的空间的指针。

🔥如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查。

🔥返回值类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者自己来决定。

🔥如果参数 size 单位是字节，如果size为0，malloc的行为是标准未定义的，取决于编译器。

举例：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(20);//开辟20个字节的空间

	return 0;
}

注意：指针变量p的类型是 int* 型，所以malloc开辟后的空间需要进行强制类型转换。

那malloc开辟空间在内存的什么地方呢？

可以看到，内存分为这几个区域：栈区、堆区、静态区、常量区和代码区，不同区域所存储的数据不同，由malloc申请的内存在内存的堆区。

💯代码演示：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(20);//开辟20个字节的空间
	if (p == NULL)//判断申请是否成功
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", *(p + i));//1 2 3 4 5
	}

	return 0;
}

注意malloc是在头文件 <stdlib.h> 中声明的。

• 🌰2.free

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

cpp 复制代码 
void free (void* ptr);

我们再内存中用malloc开辟了动态内存，当我们使用完毕后应该会还给操作系统，正所谓有借有还，再借不难~

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

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

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

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

💯代码演示：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	int* p = (int*)malloc(n * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < n; i++)
	{
		*(p + i) = 0;
	}

	free(p);//释放
	p = NULL;//释放后p是野指针，需要置为NULL

	return 0;
}

🍋知识点二：calloc和realloc

• 🌰1.calloc

C语言还提供了一个函数叫做calloc，calloc函数也是用来动态内存分配，函数原型如下：

cpp 复制代码 
void* calloc(size_t num, size_t size);

🔥函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

🔥与函数malloc的区别只在于calloc会在返回地址之前把之前申请的空间的每个字节都初始化为0。

举例：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p1 = (int*)malloc(5 * sizeof(int));
	int* p2 = (int*)calloc(5, sizeof(int));

	return 0;
}

上述p1、p2利用malloc和calloc所开辟的空间大小是一样的，但p2返回时会在返回地址之前把之前申请的空间的每个字节都初始化为0，也就是calloc比malloc多了一步初始化。

在使用上大同小异。

💯代码演示：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p2 = (int*)calloc(5, sizeof(int));
	if (p2 == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用
	//...
	free(p2);
	p2 = NULL;

	return 0;
}

• 🌰1.realloc

有时我们会发现过去申请的空间太小了，或有时候又会觉得我们申请的空间过大了，那为了合理的使用内存，我们需要对内存的大小做出灵活的调整，就有了realloc函数，原型如下：

cpp 复制代码 
void* realloc (void* ptr, size_t size);

🔥 ptr 是要调整的内存地址， size 是调整时候的新大小，返回值为调整之后内存的起始位置。

🔥这个函数在调整原内存空间的基础上，还可能会将原来内存中的数据移动到新空间。

💯代码演示：

cpp 复制代码 
#include<stdio.h> 
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//20
	//1 2 3 4 5
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//希望将空间调整为40个字节
	realloc(p, 40);
	
	return 0;
}

上面realloc函数在调整内存空间的时候是存在两种情况的：

🎉🎉🎉情况1：原有空间之后有足够大的空间🎉🎉🎉

这种情况扩容为40个字节，后面尚未分配的空间足够20个字节的大小，那直接从后面的空间中使用20个字节，然后返回起始地址 ptr 就可以了。

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

但如果是这种情况，后面尚未分配的空间没有20个字节，会在堆区上寻找一块新的空间，并且大小为40个字节，同时将原有的数据拷贝一份到新的空间，同时释放旧的空间，此时返回的是新空间的地址 new 而非 ptr。

由于上述的两种情况，在使用realloc函数的时候就需要更加注意。

💯代码演示：

cpp 复制代码 
#include<stdio.h> 
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//20
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//希望将空间调整为40个字节
	int* ptr = (int*)realloc(p, 40);
	if (ptr != NULL)//调整成功
	{
		p = ptr;
		//对p进行后续操作
		for (int i = 5; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
		for (int i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	else//调整失败
	{
		perror("realloc");
		free(p);
		p = NULL;
	}
	
	return 0;
}

如果大家能够读懂上面的代码，相信对动态内存分配的四个函数都已经理解深刻了。

🍋知识点三：常见的动态内存的错误

• 🌰1.对NULL指针的解引用操作

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

对于任何动态内存的开辟（malloc、calloc），都有可能开辟失败，如果开辟失败将会返回空指针，如果我们不加以检查，就会造成对空指针的解引用，实际上malloc是不能开辟 INT_MAX 这么大的一个空间的，所以我们一定要进行检查，正确格式如下：

cpp 复制代码 
void test()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		*p = 20;//此时p不为空指针
		free(p);
	}
}

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

cpp 复制代码 
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);
}

上面我们开辟了一个40个字节大小的空间，能够放入10个 int 型的整数，但是在for循环中我们给空间赋值了11位整数，这样会造成动态开辟空间的越界访问，程序将会崩溃。

注意：程序执行到exit语句将会直接退出程序，执行到return语句将会直接退出当前函数。

• 🌰3.对非动态开辟内存的free释放

cpp 复制代码 
void test()
{
	int a = 10;
	int* p = &a;
	free(p);//ok?
}

大家可以返回去看看free函数的介绍，其中说明了如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。上面p指向的并不是动态开辟的空间，不应该使用free也不需要使用free（程序会崩溃），因为对于局部变量而言，具有自动存储期的变量在进入作用域时创建，出作用域时销毁。

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

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

p++之后，不再指向动态内存的起始位置，而是跳过了一个 int 后的位置

在使用free释放空间的时候，一定要把空间的起始位置传递给free，不能随便传入一个地址，或从半途中来释放其中的一部分，这是不行的，否则程序会崩溃。

• 🌰5.对同一块动态内存多次释放

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

p申请了100字节大小的空间，但是却对这块空间释放了两次，这是不行的，程序也会崩溃 。但如果在第一次释放后将p置为 NULL ，那就不会又问题了，因为如果free函数的参数是 NULL 指针，则函数什么事情都不做。

• 🌰6.动态开辟内存忘记释放（内存泄露）

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

p申请了100个字节大小的空间，但是却忘记了将其释放，这会造成内存泄露，在 test 函数中没有释放，那出了这个函数就连释放的机会也没有了，也就是这块内存再也找不见了，没有还给操作系统。

所以我们再平常写代码的时候尽量要做到谁申请的资源谁去释放，或者给别人去用。如果不去释放，程序结束后，也会由操作系统来自动回收。

🍋知识点四：动态内存经典笔试题分析

• 🌰1.题目1

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

请问运行 Test 函数会由什么样的结果？

有些人认为：创建字符指针并置为 NULL ，传参给 GetMemory函数，将p修改为指向动态开辟100个字节大小空间的指针，并将字符串"hello wolrd"拷贝给str。

但真的是这样吗？

其实由这张图我们就能很清楚地发现，我们传过去的是指针变量，而且是想修改这个指针变量自身的值，接收指针变量的p只是str的一份临时拷贝，对形参的修改并不会影响到实参，所以str还是 NULL ，而p出了函数后就会被销毁。形成了对 NULL 指针的访问，即非法访问。想要修改传过去的参数，就应该传它的地址，即传址调用。

上面代码的两个问题：

🔥p是形参变量，出了函数变被销毁，而p指向的是动态申请的内存，这样就会造成内存泄露。

🔥str指针变量中依然是 NULL 指针，如果要拷贝，就会发生内存的非法访问，可能导致程序崩溃。

💯正确代码：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p)//二级指针接收
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//想要修改str，就要传str的指针
	strcpy(str, "hello world");
	printf(str);
    free(str);
    str==NULL;
}
int main()
{
	Test();
	return 0;
}

• 🌰2.题目2

返回栈空间地址的问题

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

请问运行 Test 函数会由什么样的结果？

题目大体的意思是想将字符指针str指向字符数组"hello world"然后打印出这个数组，但上面代码是实现不了预期功能的。

由与数组p在函数内部，**属于局部变量，所以它的作用域范围只有它创建到函数结束这一段，**而出了这个函数p就会被销毁，p就会被还给操作系统，而这块空间有没有被别人改掉，里面到底存放了什么就不从而知了，所以str并不能正确的指向字符数组，而结果将会是乱码。

我们再看看另外一个同样是存在返回栈空间地址问题的代码：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
void Test(void)
{
	int n = 100;
	return &n;
}
int main()
{
	Test();
	return 0;
}

这个代码也是相同的问题，可以自己分析以下。

• 🌰3.题目3

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	int* p = Test();
	return 0;
}

请问运行 Test 函数会由什么样的结果？

这段代码和我们之前题目1优化的版本其实是相似的，唯一还有个问题就是堆上申请的空间没有主动释放，所以会造成内存泄露。

正确代码和题目1类似，大家可以参照自己改改，其实就多了一步释放，也是非常简单的。

• 🌰4.题目4

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
void Test(void)
{
	char* str = (char*)malloc(100); 
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

这段代码在拷贝后释放了str，但是大家请注意，free是释放str指向的空间，本质上是放弃了str指向的空间的使用权限，但是str中依然保存着前面malloc申请的100个字节的起始地址。也就是说，还是会执行if语句中的内容，会将world拷贝到str的空间上，但是str指向的空间已经不属于当前程序的空间了，若坚持拷贝，就形成了非法访问内存，程序可能崩溃。

因此，为了避免出现野指针的相关问题，free（str）后应该将其置为 NULL 。

🍋知识点四：柔性数组

也许你从来没有听说过**柔性数组（flexible array）**这个概念，但是它确实是存在的。

C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。

我们从定义中提取出关键信息：

🔥结构体中，最后一个成员。

🔥最后一个成员是数组，数组没有指定大小。

这样的数组才叫做柔性数组。

例如：

cpp 复制代码 
struct S
{
	char c;
	int i;
	int arr[];//柔性数组
	//或int arr[0]
};

• 🌰1.柔性数组的特点

🔥结构体中的柔性数组成员前面必须有至少一个其他成员。

🔥sizeof 返回的这种结构体大小不包括柔性数组的内存。

🔥包含柔性数组成员的结构体用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小。

💯代码1：

cpp 复制代码 
#include <stdio.h>
struct S
{
	int i;
	int arr[];
};
int main()
{
	printf("%zd\n", sizeof(struct S));//结果为4

	return 0;
}

• 🌰2.柔性数组的使用

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
struct S
{
	int n;
	int arr[];
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	for (int i = 0; i < 5; i++)
	{
		ps->arr[i] = 1;
	}
	//调整空间
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 10 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	//使用...

	//释放
	free(ps);
	ps = NULL;

	return 0;
}

这段代码看着很长，其实很多都是咱再上面讲过的一些格式，柔性数组柔性再什么地方，我们看图说话：

也就是说，我们可以用realloc来调整柔性数组的大小，而n的大小是sizeof（struct S）不变的，变化的是k*sizeof（int）中的k。

我们也可以用指针的方式实现数组的柔性变化：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
struct S
{
	int n;
	int *arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	if (ps == NULL)
	{
		perror("ps: malloc");
		return 1;
	}
	ps->arr = (int*)malloc(5 * sizeof(int));
	if (ps->arr == NULL)
	{
		perror("ps->arr: malloc");
		return 1;
	}
	//使用
	ps->n = 100;
	for (int i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	//调整数组大小
	int* ptr = (int*)realloc(ps->arr, 10 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	//使用...

	//释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

也就是说，arr如果是个指针，那么它指向的内容也是可以动态开辟的，就可以在不使用柔性数组的情况下实现数组的柔性变化。

两种方式都是可以的。

• 🌰2.柔性数组的优势

上面两种方案，柔性数组的方式有什么优势呢？

🔥方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并且把整个结构体返回给用户，用户调用free可以释放结构体，但是用户可能并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并且返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

🔥有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎片（其实也没多高了，反正都跑不了要用作偏移量的加法来寻址）。

扩展阅读： 🎉🎉🎉C语言结构体里的成员数组和指针🎉🎉🎉

•🌙SumUp 结语

C语言动态内存管理的学习到这里就结束啦~后面就会进入文件操作的学习。在这里希望大家能够将前面的C语言的的基础知识进行回顾复习，使整个纯C学习是连贯的，这样更加利于我们的学习和理解以及继续拓展。

如果大家觉得有帮助，麻烦大家点点赞，如果有错误的地方也欢迎大家指出~

相关推荐
栗豆包4 分钟前
w118共享汽车管理系统
java·spring boot·后端·spring·tomcat·maven
lly20240610 分钟前
Highcharts 饼图：数据可视化利器
开发语言
夜半被帅醒10 分钟前
MySQL 数据库优化详解【Java数据库调优】
java·数据库·mysql
薄荷故人_15 分钟前
从零开始的C++之旅——红黑树封装map_set
c++
lw向北.16 分钟前
Qt For Android之环境搭建（Qt 5.12.11 Qt下载SDK的处理方案）
android·开发语言·qt
万亿少女的梦16817 分钟前
基于Spring Boot的网络购物商城的设计与实现
java·spring boot·后端
qystca31 分钟前
洛谷 P11242 碧树 C语言
数据结构·算法
IT女孩儿38 分钟前
JavaScript--WebAPI查缺补漏（二）
开发语言·前端·javascript·html·ecmascript
冠位观测者38 分钟前
【Leetcode 热题 100】124. 二叉树中的最大路径和
数据结构·算法·leetcode
m0_7482389238 分钟前
webgis入门实战案例——智慧校园
开发语言·ios·swift
热门推荐
0119个Web前端交互式3D JavaScript框架和库02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07ZZ038 物联网应用与服务赛题第J套08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10VSCode插件 —— Cody AI （免费AI助手！）