c语言之动态内存管理篇

最新推荐文章于 2024-10-01 20:11:33 发布
最新推荐文章于 2024-10-01 20:11:33 发布
阅读量222 收藏 1
点赞数 2
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyx_bc/article/details/129225479
版权
文章详细介绍了C语言中的动态内存管理，包括malloc、free、calloc和realloc函数的使用，常见动态内存错误如空指针解引用、越界访问等，并讨论了柔性数组的概念和特点。同时，文章强调了内存释放和避免内存泄漏的重要性。
摘要由CSDN通过智能技术生成

动态内存管理

动态内存管理

1.为什么存在动态内存分配

int a=10;//固定向内存申请了4个字节
int arr[10];//向内存申请了连续的空间
//c99规定的变长数组
int n=0;
int arr[n]；//一旦申请空间后就不能改变了

我们不难发现以上这些一旦向内存申请好空间就不能改变了，c语言中有没有某种东西，当我申请完空间后可以随时变大变小？这就是我们今天要介绍的动态内存管理，它相比于静态的更加灵活。

2.动态内存函数的介绍

在介绍动态内存分配函数前，我们了解过：
在这里插入图片描述

2.1malloc函数

堆区内存申请函数，这个函数申请的是连续的空间

头文件：#include<stdlib.h>

void* malloc (size_t size);

size：申请多少字节
void*：返回指向那块空间的起始地址
申请失败：返回NULL，比如INT_MAX
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器（vs上是不报错的）
注意：这个函数只是申请了多少字节，但是没标明申请的是什么类型，所以这个需要我们来定义

//动态内存管理
#include<stdio.h>
#include<stdlib.h>//注意头文件
int main()
{
	//申请40个字节，存放10个int
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印1~10
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

但是这段代码还有问题，就是你向堆区申请了空间，但是你又占着空间不用，虽然操作系统会在程序结束后回收，但是我们最好还是主动去还，以免造成不必要的麻烦

2.2free

这就是释放动态开辟内存的函数

头文件：#include<stdlib.h>

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的，就是说它只是作用于堆区，对其他区是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

void free (void* ptr);

ptr：指向开辟空间的起始地址

//动态内存管理
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//申请40个字节，存放10个int
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印1~10
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放堆区开辟的空间
	free(p);
	return 0;
}

在这里插入图片描述

这段代码还是有风险的，free函数只会释放空间，但不会改变p的地址，那么问题就来了，万一有人通过p非法访问怎么办？这就需要将p置为NULL。

//动态内存管理
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//申请40个字节，存放10个int
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印1~10
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放堆区开辟的空间
	free(p);
	p=NULL;//注意
	return 0;
}

2.3calloc函数

用来开辟一个数组，并将这个数组每一个元素初始化为0

头文件：#include<stdlib.h>

void* calloc (size_t num, size_t size);

num：数组元素个数
size：每个元素大小
申请失败：返回NULL
注意：这个函数没标明申请的是什么类型，所以这个需要我们来定义

//}
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//申请一个整型数组，10个元素，每个元素大小为int
	int* p = (int*)calloc(10,sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//直接打印10个元素
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放开辟的空间
	free(p);
	//防止非法访问
	p = NULL;
	return 0;
}

运行结果：
0 0 0 0 0 0 0 0 0 0

2.4realloc函数

动态内存调整函数

头文件：#include<stdlib.h>
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

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

ptr：指向开辟的空间，如果传NULL，功能相当于malloc函数
size：调整为多少字节
调整失败：返回NULL
注意：这个函数会将调整后的地址返回来，但是也没说是什么类型，所以类型需要我们来定义

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//向堆区开辟空间
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//初始化为1
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
	//调整为10个元素
	p = realloc(p, 10 * sizeof(int));//？
	//释放空间大小
	free(p);
	//防止非法访问
	p = NULL;
	return 0;
}

上面的代码还是有点小问题，就是能不能用p来接收新调整的空间的起始地址，这里分为两种情况
在这里插入图片描述
在这里插入图片描述
如果直接用p去接收，如果扩容失败，返回NULL，那么你就会把原数据弄丢，所以要用新指针接收。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//向堆区开辟空间
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//初始化为1
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
	//调整为10个元素
	int* ptr = realloc(p, 10 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	//初始化为1
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 1;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放空间大小
	free(p);
	//防止非法访问
	p = NULL;
	return 0;
}

3.常见的动态内存错误

3.1对空指针的解引用操作

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	//如果不判断，万一为NULL
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		//如果为NULL，那么对NULL加i为野指针，对野指针操作是危险的
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

3.2对内存开辟的空间进行越界访问

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	//越界访问
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		*(p + i) = 1;
	}
	free(p);
	p = NULL;
	return 0;
}

3.3对非动态内存开辟使用free函数

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//局部变量是存放在栈区的
	int a = 10;
	int* p = &a;
	//free函数只能释放堆区的空间
	free(p);
	p = NULL;
	return 0;
}

3.4使用free释放动态开辟空间的一部分

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	int i = 0;
	for (i = 0; i < 25; i++)
	{
		*p = i;
		p++;
	}
	//注意结束后，p不指向开辟空间的起始位置
	//那么free就只会释放一部分空间
	free(p);
	p = NULL;
	return 0;
}

3.5对同一块动态内存多次free

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10, 4);
	if (p == NULL)
	{
		return 1;
	}
	free(p);
	//...
	//p为野指针了
	//但是p=NULL就不会出错，因为free（NULL）；什么也不做
	//有进行一次free
	free(p);
	return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	//...
	//忘记释放了
}
int main()
{
	test();
	return 0;
}

这种错误很危险，会将内存泄露
解决方法：

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}


#include<stdio.h>
#include<stdlib.h>
//改函数中进行了malloc操作，返回了malloc开辟空间的起始地址
//记得释放空间
int* test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	return p;
}
int main()
{
	int* ptr=test();
	//记得释放空间
	free(ptr);
	ptr = NULL;
	return 0;
}

4.几个经典的面试题

#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.存在内存泄漏，你申请了空间，调用完函数p会销毁，没人知道这个空间在哪，就会造成泄露
2.传值调用：对形参的改变不影响实参，str拷贝形成了非法访问

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
//该函数进行了malloc操作
//记得free
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;
}

输出结果：
hello world

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

这个代码是有问题的，运行结果并不是hello world。
首先，调用Test函数，再调用GetMemory函数，str接收了这个数组的首元素地址，但是GetMemory会被销毁，str接收的地址就无明确指向关系，所以是打印出的东西是乱的，下面的一段代码同理。

#include<stdio.h>
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int*p=test();
	printf("hehe\n");
	printf("%d\n", *p);
	return 0;
}


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

这个代码的问题就是非法访问

在这里插入图片描述

C/C++程序内存分配的几个区域：

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

5.柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

struct stu
{
	char c;
	int i;
	int arr[];//1.结构体中的最后一个元素是数组
	//2.数组元素个数是未知的
	//int arr[0];这种写法也是对的
};

5.1柔性数组的特点

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

#include<stdio.h>
#include<stdlib.h>
struct stu
{
	char c;
	int i;
	int arr[];

};
int main()
{
	//柔性数组是不参与结构体计算的
	printf("%d\n", sizeof(struct stu));
	//柔性数组的开辟是用动态内存开辟的
	struct stu* pc = (struct stu*)malloc(sizeof(struct stu) + 10 * sizeof(int));
	if (pc == NULL)
	{
		return;
	}
	pc->i = 10;
	//对数组进行初始化
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(pc->arr+i) = i + 1;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", pc->arr[i]);
	}
		//增容
	struct stu* ptr = (struct stu*)realloc(pc, sizeof(struct stu) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		pc = ptr;
	}
	else
	{
		perror("realloc");
		return;
	}
	//即使增容了，柔性数组也是不参与结构体大小计算的
	printf("%d\n", sizeof(struct stu));
	free(pc);
	pc = NULL;
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
struct s
{
	int i;
	int* p;
};
int main()
{
	struct s* pc = (struct s*)malloc(sizeof(struct s));
	if (pc == NULL)
	{
		perror("malloc->pc");
		return 0;
	}
	pc->i = 0;
	pc->p = (int*)malloc(10 * sizeof(int));
	if (pc->p == NULL)
	{
		return;
	}
	//释放
	free(pc->p);
	pc->p = NULL;
	free(pc);
	pc = NULL;
	return 0;
}

上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处

第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

总结：

以上就是本篇的所有内容了，如果喜欢本篇，不妨点个赞，如果想要持续了解更多，欢迎关注我，谢谢大家的观看，下期间！

梦呓dream
关注
深入解析C语言中的内存分配相关问题
09-03
在C语言中，内存管理是编程过程中的关键环节，它涉及到如何有效地分配和释放内存，以确保程序的正常运行和资源的有效利用。本篇文章将深入探讨C语言中的内存分配问题，特别是关注内存泄漏以及如何使用malloc和指针来...
一个动态内存管理模块的实现
08-05
【一个动态内存管理模块的实现】这篇文章主要介绍了一个专门针对C语言环境的动态内存管理模块，该模块旨在检测和防止常见的内存错误，如内存泄漏和写内存越界。C语言虽然因为其灵活性和效率受到广泛使用，但不当的...
C语言获取消耗内存的方法
09-03
在C语言中，内存管理是程序员必须关注的重要部分。程序在运行时需要动态分配和释放内存，以适应不同阶段的数据需求。本篇文章将详细介绍如何在C语言中获取消耗的内存，特别是通过`malloc()`函数来实现内存分配。 `...
C语言库函数之内存操作
07-03
本篇文章将深入探讨C语言库函数中的内存操作，主要包括动态内存分配、内存释放以及内存拷贝等关键概念。 一、动态内存分配 在C语言中，我们不能像在高级语言如Java或Python中那样直接声明一个变量就自动分配内存。...
基于c语言实现的图书管理系统源码
05-11
7. **内存管理**：在C语言中，内存分配和释放需要程序员手动处理。在创建和修改图书对象时，要合理使用`malloc`和`free`函数，防止内存泄漏。 通过对这个图书管理系统源码的分析，我们可以学到C语言在实际项目中的...
杨辉三角-C语言
m0_56065966的博客
09-26 365
轻松用C语言输出杨辉三角
第十四届蓝桥杯真题Java c组A.求和(持续更新)
音符犹如代码的博客
09-28 332
我们还可以使用数学公式来优化这个过程。
C 语言中 & 符号的两种用途
m0_46398975的博客
09-23 410
C 语言中 `&` 符号的两种用途
第十四届蓝桥杯真题Python c组F.棋盘(持续更新)
音符犹如代码的博客
09-28 416
小蓝拥有 n × n 大小的棋盘，一开始棋盘上全都是白子。小蓝进行了m次操作，每次操作会将棋盘上某个范围内的所有棋子的颜色取反(也就是白色棋子变为黑色，黑色棋子变为白色)。请输出所有操作做完后棋盘上每个棋子的颜色。接下来m行每行包含四个整数 X1，Y1，X2，Y2，相邻整数之间使用一个空格分隔，表示将在X1至X2行和Y1至Y2列中的棋子颜色取反。输出n行，每行n个0或1表示该位置棋子的颜色。如果是白色则输出0，否则输出1。输入的第一行包含两个整数n，m，用一个空格分隔，表示棋盘大小与操作数。
C语言——文件操作
2401_82924480的博客
09-24 784
文件操作
C语言 | 第六章 | 进制 位运算
ZJC744575的博客
10-01 627
十进制转其他进制----除基逆向取余法其他进制转十进制----从最低位开始，将每个位上的数提取出来，乘以2、8、16的(位数-1)次方二进制转其他进制----低位开始，将二进制数每四位一组/三位一组，转成对应的十六进制/八进制数即可其他进制转二进制-----将十六进制/八进制数每1位，转成对应的4位/3位的一个二进制数即可。它们的运算规则是：按位与&： 两位全为１，结果为1，否则为0按位或|: 两位有一个为1，结果为1，否则为0按位异或 ^: 两位一个为0,一个为1，结果为1，否则为0。
家政服务管理平台 源码+数据库+论文（JAVA+SpringBoot+Vue.JS+MySQL）.zip
10-02
家政服务管理平台 源码+数据库+论文（JAVA+SpringBoot+Vue.JS+MySQL） 启动教程：https://www.bilibili.com/video/BV11ktveuE2d
基于SpringBoot和Bootstrap的Kettle 8.3任务调度系统设计源码
10-02
该项目是一款基于SpringBoot和Bootstrap框架构建的Kettle 8.3任务调度系统源码，包含675个文件，涵盖256个JavaScript文件、198个Java源文件、51个PNG图片文件、34个CSS文件、31个HTML文件、30个GIF文件、11个JPG文件、9个XML文件、7个YML文件、7个TXT文件。系统后端利用SpringBoot框架实现，前端界面采用Bootstrap设计，同时借鉴了zhaxiaodong9860的代码并进行优化，提供便捷的页面管理功能。后台代码基于Kettle 8.3 API进行工具化编写，旨在提升使用效率。
实例程序原理图加文档MSP430单片机51单片机室内环境检测仪
10-02
实例程序原理图加文档MSP430单片机51单片机室内环境检测仪
鲁东大学在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
中央财经大学在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
基于Java语言的JDBC操作封装与简化数据查询的commons-dbutils设计源码
10-02
本项目为基于Java语言的JDBC操作封装工具，旨在简化数据查询和记录读取过程，并采用commons-dbutils设计源码。该工具集包含135个文件，其中Java源文件95个，XML配置文件16个，其他包括txt、yml、md等多种文件类型。本项目并非完整持久层框架，但提供了一系列JDBC操作封装，便于开发者进行数据操作。
基于Java与HTML的Servlet之间Cookie数据共享设计源码
最新发布
10-02
该项目是一款基于Java与HTML开发的Servlet之间Cookie数据共享的设计源码，共包含25个文件，包括18个XML配置文件、2个Java源文件、2个HTML文件、1个Idea项目配置文件。主要功能是通过Cookie技术实现两个Servlet之间的数据共享，适用于需要在不同组件间传递用户数据的Web应用开发场景。
【乳腺癌检测】GUI医学乳腺癌检测处理系统（自适应中值滤波 GMM分类）【含Matlab源码 8770期】.mp4
10-02
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
C语言动态内存管理：malloc, free, realloc
总结，这篇复习资料强调了C语言中动态内存管理的重要性，提供了`malloc()`、`free()`和`realloc()`函数的使用方法，以及宏定义和typedef的应用，还有指针的基本操作。这些都是C语言编程中的核心知识点，理解和掌握...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值