【进阶C语言】动态内存分配

news2024/12/1 8:32:34

本章大致内容介绍：

1.malloc函数和free函数

2.calloc函数

3.realloc函数

4.常见错误案例

5.笔试题详解

6.柔性数组

一、malloc和free

1.malloc函数

（1）函数原型

函数参数：根据用户的需求需要开辟多大的字节空间，为无符号的字节。

返回值：malloc函数成功开辟内存后，会返回该内存的起始地址，可以根据需要强制转换成任意的类型；若开辟空间失败，则会返回空指针（NULL）。

头文件：#include<stdlib.h>

（2）使用方法

1）申请空间：

#include<stdio.h>
#include<stdlib.h>
int  main()
{
	int* p = (int*)malloc(40);
	return 0;
}

目的：申请十个整形空间，所以参数传：4*10=40。

结果：用一个整形指针来接收其返回值

2）检查安全和使用

#include<stdio.h>
#include<stdlib.h>
int  main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)//必须对指针安全性检查
	{
		printf("申请空间失败\n");
		return;
	}
	//申请成功就开始用
	int i = 0;
	for (i=0;i<10;i++)
	{
		*(p+i) = i;
	}
	i = 0;
	for (i=0;i<10;i++)
	{
		printf("%d\n",*(p+i));
	}
	return 0;
}

当使用结束之后，我们需要删除该动态生成的空间，则需要对空间进行释放，这就是我们接下来讲的free。

2.free函数

（1）函数原型

1.参数为动态开辟内存的首地址

2.无参数返回

3.头文件#include<stdlib.h>

（2）配合动态内存开辟的函数使用

前面malloc函数开辟的内存还没释放，接下来它们配合使用。

#include<stdio.h>
#include<stdlib.h>
int  main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("申请空间失败\n");
		return;
	}
	//申请成功就开始用
	int i = 0;
	for (i=0;i<10;i++)
	{
		*(p+i) = i;
	}
	i = 0;
	for (i=0;i<10;i++)
	{
		printf("%d\n",*(p+i));
	}
	free(p);
	p = NULL;//及时将指针置空
	return 0;
}

注意事项:

1.free只能释放由动态内存开辟的空间

2.free释放的是指针所指向的那块空间，释放后指针仍在，但是指向的空间不咋了，就会变成野指针，所以我们需要及时置空。

二、calloc

1.函数定义

函数参数：第一个参数是需要开辟的数据个数，第二个是该数据类型的内存大小。

返回值：calloc函数成功开辟内存后，会返回该内存的起始地址，可以根据需要强制转换成任意的类型；若开辟空间失败，则会返回空指针（NULL）。

头文件：#include<stdlib.h>

2.calloc的使用

目的：需要开辟10个整形空间

#include<stdio.h>
#include<stdlib.h>
int  main()
{
	int* p = (int*)calloc(10,sizeof(int));
	if (p == NULL)
	{
		printf("申请空间失败\n");
		return;
	}
	//申请成功就开始用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;//及时将指针置空
	return 0;
}

运行结果：

根据malloc和calloc函数使用的两段代码，好像除了名字和参数之外，其他没什么不同呀？其实他们还有一处区别。

3.calloc函数与malloc函数的区别

（1）区别

malloc函数开辟好空间之后，并不会对其初始化，但是calloc函数开辟好空间之后，会将数据的每一个字节都初始化成0。

（2）对照

1）malloc

2）calloc

除了以上三点不同之外，其他的都一样。所以我们需要根据内存需求，需不需要初始化内存而选择合适的开辟方式。

三、realloc

1.函数定义

realloc可以对已有的内存进行调整

函数参数：ptr是要调整的内存地址，size为内存调整之后的新大小，单位是内存总大小（字节）

返回值：内存调整后的起始地址，同样有申请内存成功和失败两种情况

头文件：#include<stdlib.h>

2.realloc申请空间成功的两种情况

（1）原空间后的空间足够大

开辟空间方式：直接原有内存之后直接追加空间，原来空间的数据不发生变化。

（2）原空间之后没有足够大的空间 

     原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小
的连续空间来使用。这样函数返回的是一个新的内存地址。而原有数据也会被拷贝到新内存中。

3.realloc的使用

#include<stdio.h>
#include<stdlib.h>
int  main()
{
	int* p = (int*)calloc(10,sizeof(int));
	if (p == NULL)
	{
		printf("申请空间失败\n");
		return;
	}
	//申请成功就开始用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	//要求加大空间内存
	int* ptr = realloc(p,40*sizeof(int));
	if (ptr == NULL)
	{
		printf("内存开辟失败\n");
		return;
	}
	p = ptr;//将新开辟好的内存赋值原地址
	free(p);
	p = NULL;//及时将指针置空
	return 0;
}

realloc的使用一般在原有空间的情况下，同样也需要对指针进行判空操作和free。

我们也可以看到，free和这些函数是紧紧联系在一起的。

四、常见错误解析

这些错误都是动态内存开辟前后的问题，与指针也有很大的联系

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

错误写法：

int main()
{
	int* p = (int*)malloc(4);
	*p = 20;
	printf("%d\n",*p);
	return 0;
}

malloc有可能开辟动态内存失败，则会返回NULL，这个时候对NULL指针解引用操作就是非法的。

正确写法：

int main()
{
	int* p = (int*)malloc(4);
	*p = 20;
	if (p == NULL)//对指针安全性限制
	{
		perror(malloc);
		return;
	}
	printf("%d\n",*p);
//后续需要对内存释放
	return 0;
}

 知识点1：在每次动态内存开辟完成之后，都要先对其指针进行判空操作；若非空，才能对其进行后续的操作。

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

错误写法：

int main()
{
	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);
}

错误的后果提示：

知识点2：在对指针解引用操作时，要注意指针所指向的个数

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

错误写法：

test()
{
	int a = 100;
	int* p = &a;
	free(p);//错误
}

知识点3：free函数只能释放动态开辟的内存，否则会非法。

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

错误写法：

int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置

当p++之后，p指向的起始位置就变了，当free(p)之后，会释放不完整，也会造成内存泄漏。

知识点4：使用指针，尽量不要改变指针指向的起始地址。可以再重新使用新指针进行++或--操作；或者+1/-1操作。

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

错误写法：

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

知识点5：切记要对内存释放，但是每一块内存有且只能释放一次。

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

错误：

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

这是忘记对动态内存的释放的，也是不可取的。

五、关于动态内存开辟的笔试题

分析下面四道代码题存在什么问题

运行Test函数会有什么样的后果

1.对NULL解引用操作

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

1.str指针为空

2.malloc开辟的空间只是被p指向，没有被str指向（相当于形参的改变不影响实参）

3.所以strcpy函数就会对NULL指针进行解引用操作

4.没有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;
}

2.

问题代码：

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

1.字符数组p为栈空间的局部变量，函数返回后会被销毁

2.数组被销毁，返回的p就是野指针（所指向的空间已不属于自己）

 类型代码情况：

int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	printf("%d\n",*p);
	return 0;
}

这种运行的结果仍然可以得到10，虽然空间依然属于p，但是值仍在，没有被其他的数据覆盖。但是下面这种情况则不行。

3.题目3

问题代码：

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释放

4.

问题代码：

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

1.str所指向的空间已被销毁

2.str变成野指针，对其解引用操作为非法

六、柔性数组

1.柔性数组的定义

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

也就是说，柔性数组不是指简单的数组，而是在结构体中的数组。

有两种写法：

第一种：

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

 a数组就称为柔性数组。但是这种定义方式容易报错，所以我们还有第二种。

第二种：

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

就是不需要指定数组的大小，数组的大小是未知的。

2.柔性数组的特点

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

（2）结构中的柔性数组成员前面必须至少一个其他成员。

因为柔性数组是不计入sizeof的计算的，只有柔性数组成员sizeof就会出错。

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

在计算包含柔性数组的结构体时，柔性数组是不计入内存的计算的。大于结构体内存大小的部分就会分配给柔性数组。

 （4）代码验证

struct S
{
	int a;
	int arr[];
};
int main()
{
	struct S s;
	printf("%zd\n",sizeof(s));//计算该结构体的内存大小
	return 0;
}

运行的结果：

 柔性数组确实是不会参加sizeof对结构体的计算

3.柔性数组的使用

（1）开辟空间

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct S
{
	int a;
	int arr[];
};
int main()
{
	struct S* ps=(struct S*)malloc(sizeof(struct S)+16);
	if (ps == NULL)
	{
		perror(malloc);
		return;
	}
	return 0;
}

（2）增容（realloc函数）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct S
{
	int a;
	int arr[];
};
int main()
{
	struct S* ps=(struct S*)malloc(sizeof(struct S)+16);
	if (ps == NULL)
	{
		perror(malloc);
		return;
	}
	struct S* str = (struct S*)realloc(ps,sizeof(struct S)+40);
	if (str != NULL)
	{
		ps = str;
	}
	else
	{
		perror(realloc);
		return;
	}
	return 0;
}

 用malloc开辟空间之后，再用reallo增容（减容）。增容之后的空间都会加在柔性数组上，这个时候数组的大小就可以根据realloc变化，因此称为柔性数组。

 

4.柔性数组的优势

（1）方便内存释放

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct S
{
	int a;
	int arr[];//定义一个柔性数组
};
int main()
{
	struct S* ps=(struct S*)malloc(sizeof(struct S)+16);
	if (ps == NULL)
	{
		perror(malloc);
		return;
	}
	struct S* str = (struct S*)realloc(ps,sizeof(struct S)+40);
	if (str != NULL)
	{
		ps = str;
	}
	else
	{
		perror(realloc);
		return;
	}
	free(ps);
	ps = NULL;
	return 0;
}

因为开辟的空间都是连续的，在一块内存中，所以只需要free一次即可。

我们再对比一下另一种写法就更加明显了。

 结构体中有指针的写法：

struct S
{
	char c;
	int i;
	int* data;//定义一个指针
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc1");
		return 1;
	}
	ps->c = 'w';
	ps->i = 100;
	ps->data = (int*)malloc(20);
	if (ps->data == NULL)
	{
		perror("malloc2");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->data[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", ps->data[i]);
	}
	//空间不够了，增容
	int* ptr = (int*)realloc(ps->data, 40);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps->data = ptr;
	}
	//增容成功就使用
	//...
	//释放
	free(ps->data);//第一次
	ps->data = NULL;
	free(ps);//第二次
	ps = NULL;
	return 0;
}

1.两次开辟空间的原因是使得他们的数据都开辟在堆区上

2.使得跟第一种一样的写法，突然第一种的优势

3.这种写法开辟的空间是不连续的，容易造成空间零碎空间，导致空间浪费。

（2）有利于访问速度和节约内存

连续的内存有益于提高访问速度，也有益于减少内存碎片，更大程度的利用内存空间。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1051558.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

nodejs+vue 网上招聘系统elementui

nodejs+vue 网上招聘系统elementui

第3章 系统分析 5 3.1 需求分析 5 3.2 系统可行性分析 5 3.2.1技术可行性&#xff1a;技术背景 5 3.2.2经济可行性 6 3.2.3操作可行性&#xff1a; 6 3.3 项目设计目标与原则 6 3.4系统流程分析 7 3.4.1操作流程 7 3.4.2添加信息流程 8 3.4.3删除信息流程 9 第4章 系统设计 11 …
阅读更多...
【PyTorch实战演练】使用Cifar10数据集训练LeNet5网络并实现图像分类（附代码）

【PyTorch实战演练】使用Cifar10数据集训练LeNet5网络并实现图像分类（附代码）

文章目录 0. 前言1. Cifar10数据集1.1 Cifar10数据集下载1.2 Cifar10数据集解析 2. LeNet5网络2.1 LeNet5的网络结构2.2 基于PyTorch的LeNet5网络编码 3. LeNet5网络训练及输出验证3.1 LeNet5网络训练3.2 LeNet5网络验证 4. 完整代码4.1 训练代码4.1 验证代码 0. 前言 按照国际…
阅读更多...
Spring Boot 常用注解详解：全面指南

Spring Boot 常用注解详解：全面指南

Spring Boot 中有许多常用的注解&#xff0c;这些注解用于配置、管理和定义 Spring Boot 应用程序的各个方面。以下是这些注解按大类和小类的方式分类&#xff0c;并附有解释和示例。 一、Spring Boot 核心注解 SpringBootApplication 解释&#xff1a;这是一个组合注解&a…
阅读更多...
反射学习笔记

反射学习笔记

反射学习笔记 一、反射入门案例 在反射中&#xff0c;万物皆对象&#xff0c;方法也是对象。反射可以在不修改源码的情况下&#xff0c;只需修改配置文件&#xff0c;就能实现功能的改变。 实体类 /*** 动物猫类*/ public class Cat {private String name;public void hi()…
阅读更多...
openGauss学习笔记-84 openGauss 数据库管理-内存优化表MOT管理-内存表特性-MOT部署服务器优化：x86

openGauss学习笔记-84 openGauss 数据库管理-内存优化表MOT管理-内存表特性-MOT部署服务器优化：x86

文章目录 openGauss学习笔记-84 openGauss 数据库管理-内存优化表MOT管理-内存表特性-MOT部署服务器优化&#xff1a;x8684.1 BIOS84.2 操作系统环境设置84.3 网络 openGauss学习笔记-84 openGauss 数据库管理-内存优化表MOT管理-内存表特性-MOT部署服务器优化&#xff1a;x86 …
阅读更多...
大学各个专业介绍

大学各个专业介绍

计算机类 五米高考-计算机类 注&#xff1a;此处平均薪酬为毕业五年平均薪酬&#xff0c;薪酬数据仅供参考 来源&#xff1a; 掌上高考 电气类 五米高考-电气类 机械类 五米高考-机械类 电子信息类 五米高考-电子信息类 土木类 五米高考-土木类
阅读更多...
Cloudflare进阶技巧：缓存利用最大化

Cloudflare进阶技巧：缓存利用最大化

1. 引言 cloudflare我想你应该知道是什么&#xff0c;一家真正意义上免费无限量的CDN&#xff0c;至今未曾有哥们喷它的。当然&#xff0c;在国内的速度确实比较一般&#xff0c;不过这也不能怪它。 CDN最大的特色&#xff0c;我想就是它的缓存功能&#xff0c;达到防攻击&am…
阅读更多...
【数据结构】归并排序、基数排序算法的学习知识点总结

【数据结构】归并排序、基数排序算法的学习知识点总结

目录 1、归并排序 1.1 算法思想 1.2 代码实现 1.3 例题分析 2、基数排序 2.1 算法思想 2.2 代码实现 2.3 例题分析 1、归并排序 1.1 算法思想 归并排序是一种采用分治思想的经典排序算法&#xff0c;通过将待排序数组分成若干个子序列&#xff0c;将每个子序列排序&#xff…
阅读更多...
安卓玩机-----给app加注册码 app加弹窗 云注入弹窗

安卓玩机-----给app加注册码 app加弹窗 云注入弹窗

在对接很多工作室业务中有些客户需要在他们自带的有些app中加注册码或者验证码的需求。其实操作起来也很简单。很多反编译软件有自带的注入功能。例如注入弹窗。这个是需要对应的注册码来启动应用。而且是随机id。重新安装app后需要重新注册才可以继续使用&#xff0c;原则上可…
阅读更多...
Ubuntu 20.04部署Promethues

Ubuntu 20.04部署Promethues

sudo lsb_release -r可以看到操作系统版本是20.04&#xff0c;sudo uname -r可以看到内核版本是5.5.19。 sudo wget -c https://github.com/prometheus/prometheus/releases/download/v2.37.1/prometheus-2.37.1.linux-amd64.tar.gz下载必要的组件。 tar -zxf prometheus-2.…
阅读更多...
python对RabbitMQ的简单使用

python对RabbitMQ的简单使用

原文链接&#xff1a;https://blog.csdn.net/weixin_43810267/article/details/123914324 RabbitMq 是实现了高级消息队列协议&#xff08;AMQP&#xff09;的开源消息代理中间件。消息队列是一种应用程序对应用程序的通行方式&#xff0c;应用程序通过写消息&#xff0c;将消…
阅读更多...
日常学习之：如何基于 OpenAI 构建自己的向量数据库

日常学习之：如何基于 OpenAI 构建自己的向量数据库

文章目录 原理前期准备依赖安装Pinecone 数据库注册Index 创建&#xff08;相当于传统数据库中的创建 table&#xff09; 基于 pinecone 数据库的代码实现尝试用 OpenAI 的 API 构建 embedding将示例的数据 embedding 后写入你的 pinecode &#xff08;构建向量数据库&#xff…
阅读更多...
【三次握手、四次挥手】TCP建立连接和断开连接的过程、为什么需要三次握手，为什么需要四次挥手、TCP的可靠传输如何保证、为什么需要等待2MSL等重点知识汇总

【三次握手、四次挥手】TCP建立连接和断开连接的过程、为什么需要三次握手，为什么需要四次挥手、TCP的可靠传输如何保证、为什么需要等待2MSL等重点知识汇总

目录 三次握手 为什么握手需要三次 四次挥手 为什么挥手需要四次 TCP的可靠传输如何保证 TIME_WAIT等待的时间是2MSL 三次握手 三次握手其实就是指建立一个TCP连接。进行三次握手的主要作用就是为了确认双方的接收能力和发送能力是否正常、指定自己的初始化序列号为后面的…
阅读更多...
【【萌新的RISCV学习之流水线通路的控制-8】】

【【萌新的RISCV学习之流水线通路的控制-8】】

萌新的RISCV学习之流水线通路的控制-8 我们在之前学习了整个单周期的模块工作流程 我们按照整体的思路分段 将数据通路划分为5个阶段 IF &#xff1a; 取地址 ID &#xff1a;指令译码和读存储器堆 EX :执行或计算地址 MEM : 数据存储器访问 WB : 写回 单周期数据通路&…
阅读更多...
Three.js加载360全景图片/视频

Three.js加载360全景图片/视频

Three.js加载360全景图片/视频 效果 原理 将全景图片/视频作为texture引入到three.js场景中将贴图与球形网格模型融合&#xff0c;将球模型当做成环境容器使用处理视频时需要以dom为载体&#xff0c;加载与控制视频动作每次渲染时更新当前texture&#xff0c;以达到视频播放效…
阅读更多...
强化学习到底是什么？它是怎么运维的

强化学习到底是什么？它是怎么运维的

https://mp.weixin.qq.com/s/LL3HfU2iNlmSqaTX_3J7fQ 强化学习是一种行为学习模型，由算法提供数据分析反馈，引导用户逐步获取最佳结果。 来源丨Towards Data Science 作者丨Jair Ribeiro 编译丨科技行者 强化学习属于机器学习中的一个子集，它使代理能够理解在特定环境中…
阅读更多...
TensorFlow入门(四、数据流向机制)

TensorFlow入门(四、数据流向机制)

session与"图"工作过程中存在的两种数据的流向机制,即:注入机制和取回机制 注入机制(feed):即通过占位符向模式中传入数据 取回机制(fetch):指在执行计算图时&#xff0c;可以同时获取多个操作节点的计算结果 实例代码如下: import tensorflow.compat.v1 as tftf…
阅读更多...
【Java】建筑工地智慧管理系统源码

【Java】建筑工地智慧管理系统源码

智慧工地系统运用物联网信息技术&#xff0c;致力于推动建筑工程行业的建设发展&#xff0c;做到全自动、信息化&#xff0c;智能化的全方位智慧工地&#xff0c;实现工程施工可视化智能管理以提高工程管理信息化水平。 智慧工地平台拥有一整套完善的智慧工地解决方案&#xff…
阅读更多...
C语言入门Day_27 开发环境

C语言入门Day_27 开发环境

前言&#xff1a; 在线编译环境涉及到联网&#xff0c;如果在没有网的情况下&#xff0c;我们就不能写代码了&#xff0c;这一章节&#xff0c;我们将会给大家介绍一下如何搭建一个本地的C语言编译环境。 如果想要设置 C 语言环境&#xff0c;需要确保电脑上有以下两款可用的…
阅读更多...
Hive【Hive（三）查询语句】

Hive【Hive（三）查询语句】

前言 今天是中秋节&#xff0c;早上七点就醒了&#xff0c;干啥呢&#xff0c;大一开学后空教室紧缺&#xff0c;还不趁着假期来学校等啥呢。顺便偷偷许个愿吧&#xff0c;希望在明年的这个时候&#xff0c;秋招不知道赶不赶得上&#xff0c;我希望拿几个国奖&#xff0c;蓝桥杯…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023