动态内存管理

最新推荐文章于 2024-09-29 07:36:50 发布
最新推荐文章于 2024-09-29 07:36:50 发布
阅读量42 收藏
点赞数
分类专栏： c语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79180171/article/details/133044145
版权

为什么要有动态内存分配

int a=10;
char str[10]="abcd";

上述的开辟空间的⽅式有两个特点：

  • 空间开辟大小是固定的。
  • 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整。

C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间，就⽐较灵活了。

malloc和free

malloc

void* malloc (size_t size);

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

malloc是在堆中申请内存

free

void free (void* ptr);

头文件：#include<stdlib.h>
free函数用来释放动态开辟的内存。

  • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
  • 如果参数 ptr 是NULL指针，则函数什么事都不做。

例如：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	int arr[num] = { 0 };
	int* ptr = NULL;
	ptr = (int*)malloc(num*sizeof(int));
	if (NULL != ptr)
	{
		int i = 0;
		for (i = 0; i<num; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);
	ptr = NULL;//free释放后应及时置空，避免出现野指针
	return 0;
}

calloc和realloc

calloc

void* calloc (size_t num, size_t size);

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

例如：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int *p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述

realloc

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

  • ptr 是要调整的内存地址

  • size 调整之后新大小

  • 开辟空间失败会返回NULL

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

  • 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

  • realloc在调整内存空间的是存在两种情况：

    • 情况1：原有空间之后有足够大的空间：要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
    • 情况2：原有空间之后没有足够大的空间：在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

  • 当realloc第一个参数为NULL时，它的功能与malloc相似

常见的动态内存的错误

对NULL指针的解引用操作

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int *p = (int *)malloc(INT_MAX / 4);
	* p = 20;//如果p的值是NULL，就会有问题
	free(p);
}
int main()
{
	test();
	return 0;
}

由此我们可以得知：在动态开辟内存时，要注意对指针进行判断，不为空指针时才可以使用。

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

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

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

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

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

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

void test()
{
	int a = 10;
	int* a = &a;
	free(a);//a并不是动态开辟的内存
}

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

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

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

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//只能用来释放起始位置
}
int main()
{
	test();
	return 0;
}

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

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

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

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

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

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

void test()
{
	int* p = (int*)malloc(100)；
	if (p != NULL)
	{
		*p = 20;
	}
}

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

由此可知：忘记释放不再使用的动态开辟的空间会造成内存泄露

动态内存经典笔试题分析

题⽬1：

#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;
}

问题：

  1. 程序崩溃
  2. 内存泄露

原因：

  • p创建的为临时变量，在GetMemory函数运行完成后就会销毁，因此str无法获得动态开辟的内存
  • malloc后未进行free

改进1：

#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);
	free(str);
	str = NULL;
}

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

改进2：

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

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;
}

在这里插入图片描述

题目2:(返回栈空间地址问题)

#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;
}

问题：非法访问内存
原因：p数组会在GetMemory函数结束后销毁，造成内存的非法访问
改进：

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


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

在这里插入图片描述

题目3：

#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()
{
	Test();
	return 0;
}

问题：内存泄漏
原因：malloc后未对动态内存空间进行free
改进：

#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);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

题目4：

#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;
}

问题：非法访问
原因：free后未置空，产生了野指针
改进：

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

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

柔性数组

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

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

//或者

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

柔性数组的特点：

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

例如：

#include<stdio.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));//输出的是4
	return 0;
}

柔性数组的使用

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

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

int main()
{
	int i = 0;
	type_a *p = (type_a*)malloc(sizeof(type_a)+100 * sizeof(int));
	p->i = 100;
	for (i = 0; i<100; i++)
	{
		p->a[i] = i;
	}
	type_a *ptr = realloc(p, 200);//可以用realloc对数组大小进行更改
	if (ptr != NULL)
	{
		p = ptr;
		ptr=NULL;
	}
	free(p);
	p = NULL;
	return 0;
}

柔性数组的优势

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
	int i;
	int *p_a;
}type_a;
int main()
{
	int i = 0;
	type_a *p = (type_a *)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int *)malloc(p->i*sizeof(int));
	for (i = 0; i<100; i++)
	{
		p->p_a[i] = i;
	}
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
	return 0;
}

通过上面两端代码的对比，我们可以知道第一个代码的好处：

  1. 方便内存释放
  2. 有利于访问速度，减少内存碎片

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

  • 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。
  • 堆区(heap)：动态内存分配，⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配⽅式类似于链表。
  • 数据段(静态区)(static)：存放全局变量、静态数据。程序结束后由系统释放。
  • 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
搞点夜点心
关注
专栏目录
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
C++动态内存管理
qq_61500888的博客
05-27 3177
带你一命通关C++内存管理 十分钟手撕C++底层原理
C/C++：动态内存管理
weixin_43908419的博客
03-04 2802
本文对C/C++动态内存管理进行了详解。第一章首先介绍了C/C++程序的内存分布情况，第二章介绍了C/C++动态内存管理相关的操作符和函数，最后一章介绍了内存泄漏。
c语言篇（动态内存管理）
小马同学的博客
12-10 5111
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
C语言：动态内存管理
热门推荐
weixin_51142926的博客
01-17 1万+
学习数据结构之前，一定要对指针、结构体、动态内存管理进行深入学习！
动态内存管理详解
eternal_yy
11-29 3194
C语言中开辟内存有很多种方式，目前我们最常用的也就是数组，但数组是在我们用到他之前就得设定好它的长度，有时很不方便。 我们知道，c语言规定，不允许设定一个未知长度的数组。（但在Linux下可以设定，但也不支持这样做）下面这段代码就会报错哟！！！ int x = 5; int arr[x];  所以，为了填补这一缺口，c语言有了动态内存，c语言提供了几个函数来管理我们的动态内存，这几个函数...
图解动态内存管理
修行的凡人的博客
10-08 2883
基于著名书籍和自我研究得出的动态内存管理的精华知识
LiteOS-M动态内存管理
wbwu的博客
01-26 4921
LiteOS-M动态内存管理LiteOS-M动态内存管理内存池初始化流程内存管理信息内存申请流程内存释放流程内存使用接口 LiteOS-M动态内存管理 LiteOS-M的动态内存管理将大块的预分配内存，通过最佳适应算法，动态分配给申请者。动态内存分配算法都无法避免内存碎片化，但通过最佳适应算法能够最大限度的减少内存碎片化。 代码实现文件： kernel/liteos_m/kernel/mm/los_memory.c kernel/liteos_m/kernel/include/los_memory.h 内
十三.动态内存管理
weixin_67401157的博客
01-16 3021
动态内存管理，主要动态内存函数，柔性数组的介绍
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
面向Android系统的动态内存管理策略.pdf
09-21
这种动态内存管理策略的实施，是通过一系列的实验来验证的，实验结果表明了优化内存管理的有效性。 针对Android系统内存管理的研究不仅限于此。国外的Kosmach J等人对Android系统中的OpenCore多媒体框架进行了分析...
Keil+C动态内存管理机制分析及改进-论文
05-11
### Keil+C动态内存管理机制分析及改进 #### 摘要 本文主要探讨了Keil+C环境下动态内存管理机制的实现原理，并针对其存在的不足之处提出了改进措施。通过深入分析Keil+C环境中的动态内存分配函数（如`malloc`, `...
第十三届蓝桥杯真题Java c组D.求和(持续更新)
音符犹如代码的博客
09-29 321
给定 n 个整数 a1, a2, · · · , an ，求它们两两相乘再相加的和，即 S = a1 · a2 + a1 · a3。对于所有评测用例，1 ≤ n ≤ 200000，1 ≤ ai ≤ 1000。对于 30% 的数据，1 ≤ n ≤ 1000，1 ≤ ai ≤ 100。输出一个整数 S，表示所求的和。请使用合适的数据类型进行运算。第二行包含 n 个整数 a1, a2, · · · an。输入的第一行包含一个整数 n。【评测用例规模与约定】
C语言 | Leetcode C语言题解之第442题数组中重复的数据
m0_59237910的博客
09-28 400
C语言 | Leetcode C语言题解之第442题数组中重复的数据
C Primer Plus 第7章——第二篇
weixin_45641816的博客
09-25 1022
P177 - P212
基于asp.net的房地产管理系统设计与实现.docx
最新发布
09-29
基于asp.net的房地产管理系统设计与实现.docx
基于asp.net的小型企业办公耗材库存管理系统设计与实现.docx
09-29
基于asp.net的小型企业办公耗材库存管理系统设计与实现.docx
STM32动态内存管理：无碎片实现
"MCU动态内存管理是一种在单片机中使用C语言实现的内存管理机制，旨在避免内存碎片并确保高效地分配和释放内存。本文着重介绍如何在STM32单片机上实现分块式的动态内存管理，包括malloc和free函数的实现。 在嵌入式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值