动态内存管理

最新推荐文章于 2025-06-12 10:41:46 发布
最新推荐文章于 2025-06-12 10:41:46 发布
阅读量803 收藏 28
点赞数 34
分类专栏： C语言 文章标签： c语言 动态内存管理 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2402_89035880/article/details/146013608
版权

目录

malloc和free

malloc

void* malloc(size_t size);

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

int main()
{
	
	//int arr[10];//栈区
	//向堆区申请40个字节的空间，用来存放整型
	int* p = (int*)malloc(INT_MAX * 1000);
	if (p == NULL)//申请空间失败
	{
		perror("malloc");//报错提醒
		return 1;//异常返回
	}
	//。。。
	return 0;//正常返回
}

free

void free(void* ptr);

free函数用来释放动态开辟的内存
如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数ptr是NULL指针，则函数什么也不做。
头文件：stdlib.h

int main()
{
	//向内存申请40个字节的空间，用来存放整型
	int* p = (int*)malloc(40);
	if (p == NULL)//申请空间失败
	{
		perror("malloc");
		return 1;//异常返回
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	//释放内存
	free(p);
	p = NULL;
	return 0;//正常返回
}

calloc和realloc

calloc

void* calloc(size_t num, size_t size);

函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0.
与函数malloc的区别只在于malloc不初始化，而calloc将每个字节都初始化为0。

int main()
{
	//int* p = (int*)malloc(40);

	//int* p1 = (int*)malloc(10 * sizeof(int));//不初始化
	int* p2 = (int*)calloc(10, sizeof(int));//初始化为0
	if (p2 == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p2[i]);
	}
	free(p2);
	p2 = NULL;
	

	return 0;
}

在这里插入图片描述

realloc

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

realloc函数可以调整动态内存开辟的大小
ptr是要调整的内存地址
size是调整之后的大小
返回值为调整之后的内存起始位置
该函数在调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
realloc在调整内存空间时存在三种情况
情况一：原有空间之后有足够大的空间，此时要扩展内存就直接在原有内存之后追加空间，原来空间的数据不发生变化。
情况二：原有空间之后没有足够大的空间，此时要扩展内存就要在堆空间上另找一个合适大小的连续空间来使用，并返回一个新的地址。
情况三：扩容失败，返回NULL指针

在这里插入图片描述

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 2;
	}
	//扩容为20个整型的空间
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr == NULL)//扩容失败
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	ptr = NULL;

	//使用
	for (i = 10; i < 20; i++)
	{
		p[i] = i + 1;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", p[i]);
	}

	//释放
	free(p);
	p = NULL;
	return 0;
}

int main()
{
	realloc(NULL, 40);//等价于malloc(40);
	return 0;
}

常见的动态内存的错误

对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(40);
	*p = 10;//如果p的值是NULL，程序就崩了
	free(p);
	p = NULL;
	return 0;
}

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i <= 10; i++)//当i = 10时，就越界访问了
	{
		*(p + i) = i + 1;
	}
	free(p);
	p = NULL;
	return 0;
}

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

int main()
{
	int a = 10;
	int* p = &a;
	*p = 100;

	free(p);//err,程序会崩溃
	p = NULL;
	return 0;
}

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i + 1;
		p++;//p的指向的位置改变了
	}
	free(p);//只释放了部分空间
	p = NULL;
	return 0;
}

对同一块动态内存多次释放

int main()
{

	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	free(p);
	//...
	free(p);//重复释放
	p = NULL;
	return 0;
}

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

void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return;
	}
}

int main()
{
	test();
	while (1)
	{
		;
	}
	//程序一直在进行，但test中开辟的内存却没有释放
	//如果是那种一直在申请内存但又不释放的程序，过一段时间电脑就卡死了
	return 0;
}

切记：动态开辟的空间一定要释放，并且要正确释放。

动态内存经典笔试题分析

题目1

void GetMemory(char* p)//形参自己也开辟空间，存放NULL指针
{
	p = (char*)malloc(100);//向堆区申请空间，返回地址给p
	//没有判断p是否为NULL，且开辟的空间没有释放
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);//传值调用
	//此时str还是NULL
	strcpy(str, "hello world");//对NULL解引用，程序会崩溃。
	printf(str);
}

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

改写1

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

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

改写2

char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}

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

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

题目2

char* GetMemory(void)
{
	//假设数组p的首地址是0x1122ff40
	char p[] = "hello world";
	return p;
}
//p是该函数的局部变量，出了作用域，p中指向的空间就还给操作系统了

void Test(void)
{
	char* str = NULL;
	str = GetMemory();//str中存放的是0x1122ff40,
	//但经过该地址找到的空间中的值已经不确定了
	printf(str);
}

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

改写

char* GetMemory(void)
{
	static char p[] = "hello world";
	//经过static修饰后，p中的元素出了作用域就不会销毁了
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

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

题目3

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");//str可能为NULL，对NULL解引用程序会崩溃
	//并且开辟的空间没有释放
	printf(str);
}

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

改写

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

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

题目4

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");//str可能为NULL，对NULL解引用程序会崩溃
	free(str);//str释放后str就是个野指针
	if (str != NULL)//野指针不为NULL，条件成立
	{
		strcpy(str, "world");//str是野指针，对野指针解引用程序会崩溃
		printf(str);
	}
}

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

改写

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

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

柔性数组

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

struct st_type
{
	int a;
	int arr[0];//柔性数组成员
};

有些编译器会报错无法编译可以改成:

struct st_type
{
	int a;
	int arr[];//柔性数组成员
};

柔性数组的特点

结构中的柔性数组成员前面必须至少一个其他成员
sizeof返回的这种结构的大小不包括柔性数组的内存
包含柔性数组成员的结构用malloc()函数进行内存的动态分配
并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小

struct st_type
{
	int a;
	int arr[0];//柔性数组成员
};

int main()
{
	printf("%zd\n", sizeof(struct st_type));//4
	return 0;
}

在这里插入图片描述

柔性数组的使用

//重命名 struct st_type 为 st
typedef struct st_type
{
	int a;
	int arr[0];//柔性数组成员
}st;

int main()
{
	//向堆区申请空间
	st* p = (st*)malloc(sizeof(st) + 10 * sizeof(int));
	//判断是否为NULL
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	p->a = 10;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p->arr + i) = i + 2;
	}
	//扩容
	st* str = (st*)realloc(p, sizeof(st) + 20 * sizeof(int));
	if (str == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = str;
	str = NULL;
	//使用
	//...

	//释放
	free(p);
	p = NULL;
	return 0;
}

正常指针形式

//重命名 struct st_type 为 st
typedef struct st_type
{
	int a;
	int* arr;
}st;

int main()
{
	//向堆区申请空间给结构st
	st* p = (st*)malloc(sizeof(st));
	if (p == NULL)
	{
		perror("malloc1");
		return 1;
	}
	//向堆区申请空间给结构st中的指针arr指向的空间
	p->arr = (int*)malloc(10 * sizeof(int));
	if (p->arr == NULL)
	{
		perror("malloc2");
		return 1;
	}
	//使用
	p->a = 10;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p->arr + i) = i + 2;
	}
	//扩容
	int* str = (int*)realloc(p->arr, 20 * sizeof(int));
	if (str == NULL)
	{
		perror("realloc");
		return 1;
	}
	p->arr = str;
	str = NULL;
	//使用
	//...

	//释放
	free(p->arr);
	p->arr = NULL;
	free(p);
	p = NULL;
	return 0;
}

柔性数组的优势

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

2.有利于提高访问速度
连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。

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

在这里插入图片描述
1.栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，
函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，
但是分配的内存容量有限。栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。

2.堆区（heap）：⼀般由程序员分配释放，若程序员不释放，
程序结束时可能由OS（操作系统）回收。分配⽅式类似于链表。

3.数据段（静态区）:（static）存放全局变量、静态数据。程序结束后由系统释放。

4.代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。
请添加图片描述

深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
C++动态内存管理
qq_61500888的博客
05-27 3325
带你一命通关C++内存管理 十分钟手撕C++底层原理
C/C++：动态内存管理
weixin_43908419的博客
03-04 3033
本文对C/C++动态内存管理进行了详解。第一章首先介绍了C/C++程序的内存分布情况，第二章介绍了C/C++动态内存管理相关的操作符和函数，最后一章介绍了内存泄漏。
动态内存管理（超级详讲）
路虽远，行则将至！事虽难，做则必成！
03-23 5547
一.为什么要有动态内存分配 二.动态内存开辟的函数：malloc 三.free函数 四.calloc函数 五.realloc函数 六.常见的动态内存错误 七.动态内存经典笔试题分析
c语言篇（动态内存管理）
小马同学的博客
12-10 5541
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
C语言：动态内存管理
热门推荐
weixin_51142926的博客
01-17 1万+
学习数据结构之前，一定要对指针、结构体、动态内存管理进行深入学习！
动态内存管理（想要了解动态内存管理，只需要看这一篇就足够了！）
秋刀鱼不做梦的编程日常
03-23 2533
动态内存管理（想要了解动态内存管理，只需要看这一篇就足够了！）
【C语言】动态内存管理（malloc，free，calloc，realloc详解 ）
学习之路，步步足迹；共享宝藏，笔记熠熠。点滴记录，历程不易；心得体会，共君品析。
08-09 3142
🦄。
内存管理：动态内存管理（main）、静态内存管理、自动内存分配
ggh_567的博客
12-14 1729
malloc free calloc realloc
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
【物联网操作系统】LiteOS内存管理详解：从静态到动态内存管理的优化与应用
04-28
文章详细介绍了LiteOS内存管理的原理，包括静态和动态内存管理。静态内存管理通过预分配固定大小的内存块，适用于固定大小的数据处理，如传感器数据存储；动态内存管理则根据实际需求灵活分配和释放内存，适用于数据...
【C/C++】namespace + macro混用场景
YZJincsdn的博客
06-08 1288
namespace + macro
【C/C++】EBO空基类优化介绍
YZJincsdn的博客
06-09 458
它没有任何数据成员（包括虚函数、虚继承等），仅有默认的构造/析构函数。根据 C++ 的标准：每个对象都必须具有唯一的地址，即使它不包含任何数据。编译器仍然会让，通常为 1 字节，以保证地址唯一性。项目是否允许空对象优化空类作为成员❌ 不允许，至少占 1 字节空类作为非虚基类✅ 可以优化掉空间空类有虚函数/虚继承❌ 无法优化（有 vptr）多继承多个相同空基类❌ 需保留唯一地址，不能优化C++20✅ 可以显式允许成员优化。
日语学习-日语知识点小记-构建基础-JLPT-N4阶段（33）：にする
qq_22146161的博客
06-09 811
自己在今年，在日本留学中，目前在语言学校，我自己不是那种一学什么的都能会的人，只能依靠自己一点一点积累，学习也分为很多种，自己跟着课本学是一种方法，如果记录下来，整理好，教给别人也是一种方式，我希望，以后每天一篇小的日语知识点小记，来构建基础，同时也可以帮助他人。本次我们学习了其他句式，句子也渐渐上来了。如果您喜欢这个系列，请关注一下，您的关注，就是我持续创作的动力。
Unity-通过Transform类学习迭代器模式
最新发布
记录
06-12 302
迭代器模式通过IEnumerable和IEnumerator接口实现集合遍历，Transform类可作为示例：实现IEnumerable返回迭代器Enumerator，后者通过MoveNext和Current遍历子节点。测试代码展示了两种遍历方式：直接使用迭代器的while循环（可复用但较复杂）和简洁的foreach语法（每次创建新迭代器）。该模式统一了集合遍历接口，是循环结构的优雅实现。
Vim 高亮命令完整学习笔记
面朝大海
06-10 701
Vim 作为强大的文本编辑器，提供了丰富的搜索和高亮功能。掌握这些命令可以大大提高文本处理效率。本文将系统介绍 Vim 的高亮搜索命令和正则表达式的使用。
Java入门学习详细版（二）
又菜又爱写
06-10 753
本文系统介绍了Java编程中控制流和面向对象编程的核心内容。控制流部分详细讲解了条件语句（if-else、switch-case）和循环结构（for、while、do-while）的使用方法及其控制语句（break、continue、return）。面向对象部分重点阐述了类和对象的概念，包括类定义、属性、方法、构造方法，以及面向对象的四大特性：封装、继承、多态和抽象。文章还介绍了Java标准库中常用类的使用方法，如String、数组、包装类等，为Java编程提供了基础指导。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值