【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++中程序内存区域划分

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

相关推荐
最爱番茄味2 分钟前
Python实例之函数基础打卡篇
开发语言·python
Uu_05kkq6 分钟前
【C语言1】C语言常见概念（总结复习篇）——库函数、ASCII码、转义字符
c语言·数据结构·算法
Oneforlove_twoforjob37 分钟前
【Java基础面试题033】Java泛型的作用是什么？
java·开发语言
engchina1 小时前
如何在 Python 中忽略烦人的警告？
开发语言·人工智能·python
向宇it1 小时前
【从零开始入门unity游戏开发之——C#篇24】C#面向对象继承——万物之父（object）、装箱和拆箱、sealed 密封类
java·开发语言·unity·c#·游戏引擎
诚丞成1 小时前
计算世界之安生：C++继承的文水和智慧（上）
开发语言·c++
Smile灬凉城6662 小时前
反序列化为啥可以利用加号绕过php正则匹配
开发语言·php
lsx2024062 小时前
SQL MID()
开发语言
Dream_Snowar2 小时前
速通Python 第四节——函数
开发语言·python·算法
西猫雷婶2 小时前
python学opencv|读取图像（十四）BGR图像和HSV图像通道拆分
开发语言·python·opencv
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04机器人编程怎么入门？05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07SQL 主从数据库实时备份08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10VSCode插件 —— Cody AI （免费AI助手！）