【C语言__动态内存管理__复习篇6】

Green小光2024-04-20 8:40

目录

前言

一、动态内存管理

二、动态内存函数

[2.1 malloc](#2.1 malloc)

[2.2 free](#2.2 free)

[2.3 calloc](#2.3 calloc)

[2.4 realloc](#2.4 realloc)

三、动态内存常见的6个使用错误

[3.1 接收malloc/calloc返回的参数后未及时检查是否为NULL](#3.1 接收malloc/calloc返回的参数后未及时检查是否为NULL)

[3.2 越界访问动态内存空间](#3.2 越界访问动态内存空间)

[3.3 对非动态开辟的内存使用free释放](#3.3 对非动态开辟的内存使用free释放)

[3.4 使用free只释放了动态内存的一部分](#3.4 使用free只释放了动态内存的一部分)

[3.5 对同一块动态内存多次释放](#3.5 对同一块动态内存多次释放)

[3.6 忘记释放动态内存造成内存泄露](#3.6 忘记释放动态内存造成内存泄露)

四、动态内存经典笔试题

[4.1 题目1](#4.1 题目1)

[4.2 题目2](#4.2 题目2)

[4.3 题目3](#4.3 题目3)

[4.4 题目4](#4.4 题目4)

五、柔性数组

六、C/C++中程序内存区域划分

前言

本篇主要讨论以下问题：

动态内存基础知识点：

  1. 为什么会出现动态内存的概念

  2. 与动态内存有关的4个函数它们分别的作用、函数的参数、返回类型以及要注意的地方是什么

  3. 理解动态开辟的内存是在堆区开辟空间的，如果不主动使用free释放开辟的动态内存空间，那么只能等程序结束后由操作系统释放了。(不可取，一定要记得自己用free去释放)

动态内存避坑指南：

  1. 动态内存开辟和使用过程中常见有哪6大错误

  2. 动态内存经典笔试题，找出代码中错误的点

柔性数组：

  1. 怎样的数组才能被称为柔性数组，含柔性数组的结构体如何开辟内存空间，如何找到结构体变量的成员变量的

了解内存有哪几个重要的区域：

7.内存有哪几个重要的区域

一、动态内存管理

  1. 在没有学习动态内存管理前 ，我们知道的为变量开辟内存的方式有两种：① 一次申请一个变量的空间 ② 一次申请一块连续的空间，但这两种申请内存空间的方式有一个明显的缺点，就是申请的空间大小一旦确定就无法更改了，于是C语言中引入了动态内存的概念，我们可以利用4个与动态内存有关的函数，实现动态开辟内存空间的效果。

二、动态内存函数

  1. 4个与动态内存有关的函数所需的头文件都是**<stdlib.h>**。

2.1 malloc

  1. malloc函数的作用：开辟size字节的动态内存空间。

  2. 语法形式：void* malloc (size_t size)

size_t size：表示向堆区一次性申请几个++比特位的空间++。

void*：返回类型之所以是void*(void*可接收任意类型的地址)是因为malloc只知道向内存的堆区申请几个字节的空间，并不知道将会存放什么类型的数据，但是程序员是知道的，所以在用malloc开辟动态内存后，一般会++立即强制类型转换，直接用其他类型的指针变量接收++。

  1. 如果malloc开辟内存成功，则返回一个指向开辟好空间的指针。

如果malloc开辟内存失败，则返回一个NULL指针，++因此在用指针接收malloc返回的地址后，需要检查指针内的地址是否为NULL++。

  1. 如果malloc函数的参数size为0，这是标准未定义的，完全取决于编译器如何处理。
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态内存
	int* ps = (int*)malloc(10 * sizeof(int));//强制转换后再接收
	if (ps == NULL)//判断是否开辟失败
	{
		perror("malloc");
		return 1;//异常返回，返回非0
	}
	return 0;
}

2.2 free

  1. free函数的作用：用于回收 malloc/calloc/realloc开辟的动态内存空间。

  2. 语法形式：void free (void* ptr)

void* ptr：表示**++指向++**malloc/calloc/realloc开辟的动态内存空间的指针。

  1. free函数只是回收了ptr所指向的动态内存空间，但此时ptr中仍然存放着指向刚刚已被回收的动态内存空间的地址，因此++在使用free函数后，应立即在后面一行中写上将ptr置NULL的操作++，防止ptr野指针被使用。

  2. 如果free函数的参数 ptr 指向的空间不是动态开辟的内存空间，这是标准未定义的，完全取决于编译器如何处理。

如果free函数的参数是NULL，则free函数将什么都不会做。

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态内存
	int* ps = (int*)malloc(10 * sizeof(int));//强制转换后再接收
	if (ps == NULL)//判断是否开辟失败
	{
		perror("malloc");
		return 1;//异常返回，返回非0
	}
	//使用动态内存

	//释放动态内存
	free(ps);
	ps = NULL;
	return 0;
}

2.3 calloc

  1. calloc函数的作用：为num个大小为size字节的元素开辟一块动态内存空间 ， 与malloc不同的是calloc++会对开辟的空间每个字节都初始化为0++。

  2. 语法形式：void* calloc (size_t num, size_t size)

size_t mun：表示要分配的元素个数。

size_t size：表示每个元素的大小，++单位是比特位++。

void*：和malloc函数的原因一致，在用calloc开辟动态内存后，++一般会立即强制类型转换，直接用其他类型的指针变量接收++。

  1. 如果calloc开辟内存成功，则返回一个指向开辟好空间的指针。

如果calloc开辟内存失败，则返回一个NULL指针，因此在用指针++接收malloc返回的地址后，需要检查指针内的地址是否为NULL++。

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态内存
	int* ps = (int*)calloc(10, sizeof(int));//强制转换后再接收
	if (ps == NULL)//判断是否开辟失败
	{
		perror("calloc");
		return 1;//异常返回，返回非0
	}
	//使用动态内存,看看calloc默认初始化的值
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(ps + i));//屏幕上打印出了10个0
	}
	//释放动态内存
	free(ps);
	ps = NULL;
	return 0;
}

2.4 realloc

  1. realloc函数的作用：调整用malloc/calloc/realloc开辟过的动态内存空间大小**。**

  2. 语法形式：void* realloc (void* ptr, size_t size)

void* ptr：表示**++指向++**malloc/calloc/realloc开辟的动态内存空间的指针。

size_t size：表示想要重新调整到的动态内存空间的大小，++单位是比特位++。

void*：和malloc函数的原因一致，在用calloc开辟动态内存后，++一般会立即强制类型转换，直接用其他类型的指针变量接收++。

  1. 如果realloc调整内存大小成功，则返回非NULL指针。

如果realloc调整内存大小失败，则返回一个NULL指针，此时如果直接用ptr接收realloc返回的地址，会使得ptr连原本的动态内存空间都无法找到，也无法将原本的动态内存空间释放，所以在用realloc调整动态内存空间后，不会直接用ptr接收，而是会++建立一个临时指针去接收，临时的指针接收后，判断如果临时指针不为NULL，则把临时指针内的地址赋值给ptr，并把临时的指针赋值为NULL；如果为NULL，则进行报错++。

  1. 关于realloc函数返回的地址是什么的问题：

情况一：原有空间之后有⾜够⼤的空间可以扩充，此时要扩展内存就直接会在原有内存之后直接追加空间，原来空间的数据不发⽣变化，realloc返回的地址值与ptr内的值一致。

情况二：原有空间之后没有⾜够⼤的空间可以扩充，扩展的⽅法是，在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤，同时把旧数据拷贝到新的空间，并释放旧的空间，这样函数返回的是⼀个新的内存地址。

  1. ++realloc函数的隐藏技能++：如果realloc函数的参数void* ptr部分传参为NULL，效果等同于malloc函数。
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态空间
	int* ps = (int*)malloc(10 * sizeof(int));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	//调整动态空间
	int* ps2 = (int*)realloc(ps, 20 * sizeof(int));
	if (ps2 != NULL)
	{
		ps = ps2;
		ps2 = NULL;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//释放动态内存
	free(ps);
	ps = NULL;
	return 0;
}

三、动态内存常见的6个使用错误

3.1 接收malloc/calloc返回的参数后未及时检查是否为NULL

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	*p = 20;//err
	return 0;
}

3.2 越界访问动态内存空间

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态内存空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	for (int i = 0; i < 12; i++)
	{
		*(p + i) = i;//err
	}
	//释放动态内存空间
	free(p);
	p = NULL;
	return 0;
}

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

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int a = 10;
	int* pa = &a;
	free(pa);//err
	pa = NULL;
	return 0;
}

3.4 使用free只释放了动态内存的一部分

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态内存空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用动态空间
	for (int i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	//释放动态内存空间
	free(p);//err
	p = NULL;
	return 0;
}

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

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//开辟动态内存空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用动态空间
	free(p);
	p = NULL;
	//释放动态内存空间
	free(p);//err
	p = NULL;
	return 0;
}

3.6 忘记释放动态内存造成内存泄露

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

void Test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		*p = 20;
	}
	//err,未释放动态内存
}

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

四、动态内存经典笔试题

4.1 题目1

题目分析：代码的目的是想让字符串拷贝到动态开辟的内存中。

错误分析：① 采用了传值调用，改变形参，实参不受影响。

② NULL不能被使用。

③ 没有free动态内存。

cpp 复制代码 
#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");//str==NULL，err
	printf(str);
}

int main()
{
	Test();
	return 0;
}
cpp 复制代码 
//修改代码
#include <stdio.h>
#include <stdlib.h>

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
    if (*p == NULL)//
    {
        perror("malloc");
    }
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//
	strcpy(str, "hello world");
	printf(str);
	free(str);//
	str = NULL;//
}

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

4.2 题目2

错误分析：① 自定义函数返回了局部变量的地址

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

char* GetMemory(void)
{
	char p[] = "hello world";//err
	//static char p[] = "hello world";//修改代码：将上一行替换
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

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

4.3 题目3

错误分析：① 没有判断malloc是否返回的NULL

② 没有用free释放动态内存空间

cpp 复制代码 
#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;
}
cpp 复制代码 
//修改代码
#include <stdio.h>
#include <stdlib.h>

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
	if (*p == NULL)//
	{
		perror("malloc");
	}
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);//
	free(str);//
	str = NULL;
}

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

4.4 题目4

错误分析：① 没有判断malloc是否返回的NULL

② free后没有及时将str置NULL

cpp 复制代码 
#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;
}
cpp 复制代码 
//修改代码
#include <stdio.h>
#include <stdlib.h>

void Test(void)
{
	char* str = (char*)malloc(100);
	if (str == NULL)
	{
		perror("malloc");
		return 1;
	}
	strcpy(str, "hello");
	free(str);
	str = NULL;
	//无意义代码
	if (str != NULL)
	{
		strcpy(str, "world");
		printf("str");
	}
}

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

五、柔性数组

  1. C99中，结构体至少2个成员变量，若最后一个成员变量是一个未知大小的数组，则这个数组叫做柔性数组。（ 未知大小的数组写法：① int arr[]; ② int arr[0]; ）

  2. 柔性数组的特点：

① 结构体中柔性数组成员前必须至少有1个其他成员变量。

② sizeof计算含柔性数组的结构体大小时，计算的结果不包含柔性数组的大小，因为柔性数组的大小是未知的。

③ 包含柔性数组的结构体在申请内存空间时要采用动态内存开辟的方式，并且开辟的动态内存空间应大于结构体内存的大小，以适应柔性数组的预期大小（总之，在创建有柔性数组的结构体变量时，不要采用struct St s；传统的方式，这样创建的结构体变量中柔性数组成员变量是没有大小的，我们应采用

struct St* p = (struct St* ) malloc(sizeof(struct St)+10* sizeof(int)；类似的方式创建结构体变量，找结构体成员变量时直接用(->)操作符即可，这种写法下相当于不同的结构体指针变量，代表着不同的结构体变量)

  1. 使用动态内存为含柔性数组的结构体开辟空间的方式，而不用平常为结构体变量开辟空间的方式的好处：① 方便内存释放 ② 访问数组相对较快 ③ 利于减少内存碎片(动态内存之间未利用到的内存称为内存碎片)
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

struct St
{
	float a;
	int arr[0];
};

int main()
{
	struct St* p = (struct St*)malloc(sizeof(struct St) + 10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	scanf("%f", &(p->a));
	printf("%f", p->a);
	for (int i = 0; i < 10; i++)
	{
		scanf("%d", &(p->arr[i]));
		printf("%d ", p->arr[i]);
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

六、C/C++中程序内存区域划分

本篇文章已完结，谢谢支持！！！

相关推荐
懒大王爱吃狼28 分钟前
Python教程：python枚举类定义和使用
开发语言·前端·javascript·python·python基础·python编程·python书籍
秃头佛爷2 小时前
Python学习大纲总结及注意事项
开发语言·python·学习
待磨的钝刨2 小时前
【格式化查看JSON文件】coco的json文件内容都在一行如何按照json格式查看
开发语言·javascript·json
XiaoLeisj3 小时前
【JavaEE初阶 — 多线程】单例模式 ＆ 指令重排序问题
java·开发语言·java-ee
励志成为嵌入式工程师4 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉5 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer5 小时前
【C++】vector 类深度解析：探索动态数组的奥秘
开发语言·c++·算法
Peter_chq5 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
记录成长java6 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
前端青山6 小时前
Node.js-增强 API 安全性和性能优化
开发语言·前端·javascript·性能优化·前端框架·node.js
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play