动态内存管理

于 2022-07-16 20:52:18 发布
阅读量986 收藏 10
点赞数 11
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lang_965/article/details/125745186
版权

目录

一、动态内存函数

1、malloc

2、free

3、calloc

4、realloc

二、常见动态内存错误

1、对NULL的解引用操作

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

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

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

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

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

三、经典笔试题

 笔试题一：

 笔试题二：

笔试题三：

笔试题四：

四、C/C++程序的内存开辟

五、柔性数组

1、柔性数组的特点：

 2、柔性数组的优势：

为什么会有动态内存分配呢？

int a = 10;//在栈空间上开辟4个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间

 上述开辟空间的方式：

a.空间大小是固定的

b.数组声明时，需指定数组长度，它所需要的内存在编译时分配

但有时候所需空间大小在运行时才知道，就要用到动态内存开辟了。

一、动态内存函数

1、malloc

void* malloc (size_t size);

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

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

b.开辟失败，则返回一个NULL指针（要检查malloc的返回值）

c.返回值的类型是void*，malloc函数并不知道开辟空间的类型，要使用者自己强制类型转换

2、free

void free (void* ptr);

free用于释放指针所指向的动态内存

举个栗子：

#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int arr[5] = { 0 };
	//动态内存开辟
	int* p = (int*)malloc(sizeof(arr));
	//检查返回类型是否是NULL指针
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *(p + i));
	}
	//free释放动态内存
	free(p);
	p = NULL;
	return 0;
}

3、calloc

void* calloc (size_t num, size_t size);

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

举个栗子：

#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//动态内存开辟
	int* p = (int*)calloc(10, sizeof(int));
	//检查p是否为NULL指针
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//打印
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

4、realloc

realloc函数可以做到对动态开辟内存大小的调整

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

ptr是要调整的内存地址

size是调整之后的新大小

返回值为调整之后的内存起始位置

realloc在调整内存空间的时候存在两种情况：

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

此时有扩展内存直接在原有内存之后追加空间，原来空间的数据不发生变化

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

此时在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址

 举个栗子：

#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//动态开辟内存
	int* p = (int*)malloc(40);
	//检查返回值是否是空指针
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//扩容
	int* ptr = (int*)realloc(p, 80);
	//确认不是空指针
	if (ptr != NULL)
	{
		p = ptr;
	}
	//使用
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

二、常见动态内存错误

1、对NULL的解引用操作

void test()
{
	int* p = (int*)malloc(40);
	*p = 20;//如果p的值是NULL，就会出现问题
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

错误纠正：

#include<string.h>
#include<errno.h>
void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
        return 1；
	}
	*p = 20;
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

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

#include<string.h>
#include<errno.h>
void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i <= 10; i++)//i=10时，数组越界访问
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

错误纠正：

#include<string.h>
#include<errno.h>
void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

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

void test()
{
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

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

#include<string.h>
#include<errno.h>
void test()
{
	//动态内存开辟
	int* p = (int*)malloc(40);
	//检查p是否为NULL
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	//释放
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

 此时p不再指向动态内存的起始位置

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

int main()
{
	int* p = (int*)malloc(40);
	free(p);
	free(p);
}

错误纠正：

int main()
{
	int* p = (int*)malloc(40);
	free(p);
	p = NULL;
	free(p);
}

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

void test()
{
	int* p = (int*)malloc(40);
	int flag = 0;
	scanf("%d", &flag);
	if (flag == 5)
	{
		return;
	}
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

如果输入5的话就忘记释放动态内存空间，造成内存泄露。

int* test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return p;
	}
	return p;
}
int main()
{
	int* ret = test();
	return 0;
}

如上代码的情况也容易释放动态内存。

所以，一定要记得正确释放动态开辟的空间。

三、经典笔试题

 笔试题一：

void GetMemory(char* p)
{
	p = (char*)malloc(100);//没有使用free释放动态内存空间，造成了内存泄露
}
void Test(void)
{
	char* str = NULL; 
	GetMemory(str);
	strcpy(str, "hello world");//形参p的值并没有带给str，str是NULL，解引用时程序会崩溃
	printf(str);
}
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");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

 改正方法二：

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

 笔试题二：

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	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);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

这道题确实用了传址调用，但却没有用free释放内存空间。

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

笔试题四：

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");//str是野指针
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

 str指向的空间释放，但没有及时使置str=NULL。

四、C/C++程序的内存开辟

其中：

栈区：主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
 堆区：一般由程序员分配释放。。

数据段（静态区）：存放全局变量、静态数据。

代码段：存放函数体（类成员函数和全局函数）的二进制代码。

五、柔性数组

柔性数组成员：结构体中最后一个元素允许是未知大小的数组。

例如：

	struct Struct
	{
		int i;
		int arr[0];//柔性数组成员，0表示未知大小
	};
	struct Struct
	{
		int i;
		int arr[];//柔性数组成员
	};

1、柔性数组的特点：

a.柔性数组成员前必须至少有一个其他成员

b.sizeof返回的结构体大小不包括柔性数组的内存

例如：

struct Struct
{
	int i;
	int arr[0];
};
int main()
{
	printf("%d\n", sizeof(struct Struct));//结构体的大小是4
	return 0;
}

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

例如：

struct S
{
	int i;
	int arr[];
};
int main()
{
	//柔性数组的使用
	struct S* p = (struct S*)malloc(sizeof(struct S) + 40);
	if (p == NULL)//检查
	{
		return 1;
	}
	p->i;
	for (int k = 0; k < 10; k++)
	{
		p->arr[k] = k;
	}
	//扩容
	struct S* p1 = (struct S*)realloc(p, sizeof(struct S) + 80);
	if (p1 == NULL)
	{
		p = p1;
		return 1;
	}
	free(p);//释放
	p = NULL;
	return 0;
}

 2、柔性数组的优势：

先看案例：

typedef struct S
{
	int i;
	int* a;//将柔性数组改为指针的形式
}S;
int main()
{
	S* p = (S*)malloc(sizeof(S));//开辟
	if (p == NULL)//检查
	{
		return 1;
	}
	p->i = 100;
	p->a = (int*)malloc(40);//开辟
	if (p->a == NULL)
	{
		return 1;
	}
	//使用
	for (int k = 0; k < 10; k++)
	{
		p->a[k] = k;
	}
	//扩容
	int* p1 = (int*)realloc(p->a, 80);
	if (p1 == NULL)
	{
		return 1;
	}
	//释放
	free(p->a);
	p->a = NULL;
	free(p);
	p = NULL;
	return 0;
}

 其实使用柔性数组的形式更好，原因如下：

a.如果我们把结构体的内存以及其成员要的内存一次性分配好，返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉

b.有益于减少内存碎片，提高访问速度

 

本次分享到此结束，后续会有不断更新，不要忘记一键三连噢~ 

发烧的CPU
关注
  • 11
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
【C语言进阶】动态内存管理/分配
HyDraZya的博客
09-06 1362
首先我们再来回顾一下内存区域的划分： 一、为什么存在动态内存管理/分配？ （1）因为内存太宝贵。 （2）如果全部是静止内存不能释放，对于小的程序可以运行完毕。但是对于大的程序，还没运行完，内存就要被占用完，此时就要发生内存泄露。 （3）假设给定一个占用内存可变大小的变量（假设是数组的长度len），那么给该变量通过函数动态分配内存后，分配内存的大小是根据数组的长度len决定的。假定用户输入len的大小是5，系统就会动态的给该数组分配长度为5的内存。 该段代码运行结束后，系统调用free(..
~动态内存管理~
眼与泪的诀别的博客
08-16 313
动态内存管理
动态内存的管理
qq_61514490的博客
03-20 848
前言： 　　通常我们使用数组的时候：必须提前用一个常量来指定数组的长度，同时它的内存空间在编译的时候就已经被分配了。但是有时候数组的长度只有在运行的时候才能知道。因此，一种简单的解决方案就是提前申请一块较大的数组，可以容纳可能出现的最多的元素； 　　使用这种放的的优点就是非常简单；但是也存在很大的缺点： 1、人为因素太大，如果元素数量超过声明的长度，就会发生数组越界，避免的方法就是在声明大一点，很浪费内存； 2、如果实际使用的元素比较少的话，就会有大量的内存被浪费掉...
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
MCU动态内存管理
11-09
### MCU动态内存管理详解 #### 一、引言 在嵌入式系统开发过程中，内存管理是一项非常重要的技术。良好的内存管理不仅可以提高程序的运行效率，还能减少内存碎片的产生，提升系统的稳定性和可靠性。本文将详细介绍...
glibc动态内存管理
01-07
malloc函数有两种不同的内存分配方法，这取决于开辟空间的大小或用户传入的具体参数，最常见的分配方法是从一大块连续的内存区域分配一部分出来，并管理这些相邻的区块以优化其使用和减少浪费不可用块。传统系统的堆...
嵌入式系统的动态内存管理
11-15
### 嵌入式系统的动态内存管理 #### 知识点一：动态内存管理的重要性 在嵌入式系统中，动态内存管理是一项至关重要的技术。它不仅能够有效地利用有限的资源，还能提高系统的稳定性和可靠性。传统的静态内存分配...
一个动态内存管理模块的实现
11-30
引言 当前，绝大多数嵌入式平台上的软件都采用C语言编写。除了代码简洁、运行高效之外，灵活操作内存的能力更是C语言的重要特色。然而，不恰当的内存操作通常也...为此，本文介绍一个增强的、可定制的动态内存管理模块
Keil+C动态内存管理机制分析及改进-论文
05-11
### Keil+C动态内存管理机制分析及改进 #### 摘要 本文主要探讨了Keil+C环境下动态内存管理机制的实现原理，并针对其存在的不足之处提出了改进措施。通过深入分析Keil+C环境中的动态内存分配函数（如`malloc`, `...
FreeRTOS动态内存管理.zip_freertos_内存管理_消息队列
09-24
动态内存管理是FreeRTOS中的关键组件，它允许在运行时分配和释放内存，使得系统能有效地利用有限的资源。本教程将深入探讨FreeRTOS的内存管理机制，以及如何通过消息队列进行进程间通信。 1. **FreeRTOS内存管理** ...
动态内存管理，支持内存碎片自动管理
01-05
动态内存有以下优点： 1，它的操作和我们在电脑上一样操作，函数名一模一样； 2，他可以移植到任何处理器芯片和单片机； 3，支持内存碎片自动管理功能； 4，在任意地方可以了申请和释放，不用考虑释放和申请顺序...
C语言动态内存管理笔记
最新发布
03-09
个人学习总结
【C/C++】内存管理
阿琪
09-25 201
栈又叫堆栈，栈是向下增长的；内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库；堆用于程序运行时动态内存分配，堆是可以上增长的；数据段–存储全局数据和静态数据；代码段–可执行的代码/只读常量。
C语言动态内存管理详解
"C语言动态内存管理笔记 - 个人学习总结" C语言中的动态内存管理是程序设计中的一个重要概念，它允许程序在运行时根据需要动态地分配和释放内存。这与静态内存分配（如全局变量和局部变量）形成了鲜明对比。在静态...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

发烧的CPU

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值