C语言——动态内存管理详解（内存结构、动态内存函数、易错题、柔性数组）

news2024/11/29 20:45:55

本篇概要

本篇文章从基本出发讲述为什么要存在动态内存分配，动态内存函数有哪些，常见的动态内存错误，一些关于内存分配的练习题以及柔性数组的相关知识。

文章目录

  • 本篇概要
  • 1.为什么存在动态内存分配
    • 1.1为什么要动态分配内存
    • 1.2内存结构
  • 2.常用的动态内存函数
    • 2.1malloc函数
    • 2.2calloc函数
    • 2.3calloc函数与malloc的区别
  • 3.其他动态内存函数
    • 3.1 realloc函数
    • 3.2 free函数
  • 4.常见的动态内存错误
    • 4.1 对NULL指针的解引用操作
    • 4.2 对动态开辟空间的越界访问
    • 4.3 对非动态开辟内存使用free释放
    • 4.4 使用free释放一块动态开辟内存的一部分
    • 4.5 对同一块动态内存多次释放
    • 4.6 动态开辟内存忘记释放（内存泄漏）
  • 5.几个经典的动态内存笔试题
    • 5.1 题目一
    • 5.2 题目二
    • 5.3 题目三
    • 5.4 题目四
  • 6.柔性数组
    • 6.1柔性数组的特点
    • 6.1柔性数组的使用及优势

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

1.1为什么要动态分配内存

平时我们创建内存如下：

int a = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的方式有两个缺点：

  1. 空间开辟大小是固定的。
  2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
    但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。

这时候就只能试试动态存开辟了

1.2内存结构

在这里插入图片描述
在这里插入图片描述

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

2.常用的动态内存函数

2.1malloc函数

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
1.如果开辟成功，则返回一个指向开辟好空间的指针。
2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
3.返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
4.如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

使用格式：

void* malloc (size_t size);
int* p = malloc(10 * sizeof(int));

2.2calloc函数

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

使用格式：

void* calloc (size_t num, size_t size);
int* p = calloc(10, sizeof(int));

2.3calloc函数与malloc的区别

**

malloc没有初始化，malloc函数申请好空间后，不会将空间初始化。

**

int main()
{
	int* p = malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述

**

calloc有初始化，calloc函数申请好空间后，会将空间初始化为0。

**

int main()
{
	int* p = calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;

	return 0;
}

在这里插入图片描述

3.其他动态内存函数

3.1 realloc函数

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

通俗的说，也就是刚开始分配的空间不够时，可以使用relloc函数重新调整空间。

使用格式：

void* realloc (void* ptr, size_t size);
int* ptr = (int*)realloc(p, 2000*sizeof(int));

1.ptr 是要调整的内存地址
2.size 调整之后新大小
3.返回值为调整之后的内存起始位置。
4.这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

提示：realloc在调整内存空间的是存在两种情况：
在这里插入图片描述

情况1：原有空间之后有足够大的空间

情况1
当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

———————————————————————————————————————————
在这里插入图片描述

情况2：原有空间之后没有足够大的空间

情况2
当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

提示： realloc(NULL,40)==malloc(40)

3.2 free函数

C语言提供了另外一个函数free，free函数用来释放动态开辟的内存。
1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数 ptr 是NULL指针，则函数什么事都不做。

使用格式：

void free (void* ptr);
free(p);

4.常见的动态内存错误

4.1 对NULL指针的解引用操作

int main()
{
	int *p = (int*)malloc(40);
	//不做返回值判断，就可能使用NULL指针，解引用
	*p = 20;
	free(p);
	return 0;
}

不做返回值判断，就可能使用NULL指针，解引用就会出问题。
所以我们一定要像上面的代码一样去判断是否为空指针

if (p == NULL)
{
perror(“calloc”);
return 1;
}

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

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

当i是10的时候越界访问

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

void test()
{
int a = 10;
int *p = &a;
free(p);
p=NULL;
}

a是在栈上申请的，没有使用malloc和calloc使用free程序会崩溃。

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

int main()
{
	int* p = calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	//0 1 2 3 4 0 0 0 0 0 
	free(p);
	p = NULL;
	return 0;
}

当指针指向第六个元素即4后面的0时，突然释放内存，程序会崩溃。
释放内存，p必须指向起始位置。

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

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

重复释放，程序会崩溃。

但是在第一个free§后面另p为空指针，那么后面再free§就不会出现问题。所以我们要养成好习惯，释放完内存将其置空。

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

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

忘记释放不再使用的动态开辟的空间会造成内存泄漏，电脑资源被浪费。

5.几个经典的动态内存笔试题

5.1 题目一

请问运行Test 函数会有什么样的结果？

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

这段代码有两个问题：
1.GetMemory函数结束后，因为没有free，所以开辟的空间还在，但是p没了（p是个形式参数），后面找不到开辟空间的地址了，内存泄露。
2.GetMemory(str)后，str为一个空指针，strcpy(str, “hello world”);是对空指针的解引用。

5.2 题目二

请问运行Test 函数会有什么样的结果？

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

GetMemory中创建了一个数组，数组p指向"hello world"的首元素地址，当函数return p后，数组中的"hello world"消失了，但是仍然指向那个首元素的地址，这时候str是野指针。printf(str);非法访问内存。

5.3 题目三

请问运行Test 函数会有什么样的结果？

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释放内存。

5.4 题目四

请问运行Test 函数会有什么样的结果？

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

free(str);过后内存释放，hello没了，但是str依然指向刚才hello的首元素地址，这是str不算是NULL，因为它依然指向一个地址，然后进入if语句时，strcpy时就是一个野指针了。非法访问内存。

6.柔性数组

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

例如：

struct S
{
char c;
int i;
int arr[0];
}

这便是一个柔性数组，int arr[0];未知大小的数组即柔性数组。

6.1柔性数组的特点

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

struct S
{
	char c;
	int i;
	int arr[0];//未知大小的数组 - 柔性数组成员
};

int main()
{
printf("%d\n",sizeof(struct S));
return 0;
}

此代码输出该结构体的大小为8，为什么是8呢因为涉及到结构体的内存对齐，不熟悉这一部分的人可以看我之前写过的博客：
链接: 结构体知识点-1.5是内存对齐

①从而没有计算arr[0]的大小，体现了第二点。
②这也侧面反映了第一点，因为前面如果没有的话，结构体大小就为0了，会出现问题。
③至于第三点，虽然结构体大小为8字节，但是开辟空间会开辟更大的空间，比如8+12个字节，后面的12个字节是为arr[0]预留的。

6.1柔性数组的使用及优势

struct S
{
	char c;//1
	//3
	int i;//4
	int arr[0];//未知大小的数组 - 柔性数组成员
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 20);
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->c = 'w';
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	//打印
	for (i = 0; i < 5; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//空间不够了
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+40);
	if (ptr != NULL)
	{
		ps = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//增容成功后，继续使用
	
	//释放
	free(ps);
	ps = NULL;

	return 0;
}

我们可以看出此代码开始后面的20个字节是放arr[]中的5个整形数据，要是如果我么还想继续放arr[]中的数据，那么我们就可以直接使用realloc进行调整，将为arr准备的20个字节增大为40个字节，十分方便。

那么柔性数组的优势怎么体现呢？我们再来看一段代码：

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 可以完成同样的功能，但是 方法1 的实现有两个好处：
第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址

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

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

相关文章

Unity实现设计模式——状态模式

Unity实现设计模式——状态模式

Unity实现设计模式——状态模式 状态模式最核心的设计思路就是将对象的状态抽象出一个接口&#xff0c;然后根据它的不同状态封装其行为&#xff0c;这样就可以实现状态和行为的绑定&#xff0c;最终实现对象和状态的有效解耦。 在实际开发中一般用到FSM有限状态机的实现&…
阅读更多...
idea Springboot 教师标识管理系统开发mysql数据库web结构java编程计算机网页源码maven项目

idea Springboot 教师标识管理系统开发mysql数据库web结构java编程计算机网页源码maven项目

一、源码特点 springboot 教师标识管理系统是一套完善的信息系统&#xff0c;结合springboot框架和bootstrap完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用springboot框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统 具有完整的源代码和数据库&…
阅读更多...
8个居家兼职，帮助自己在家搞副业

8个居家兼职，帮助自己在家搞副业

越来越多的人开始追求居家工作的机会&#xff0c;无论是为了获得更多收入以改善生活质量&#xff0c;还是为了更好地平衡工作和家庭的关系&#xff0c;居家兼职已成为一种趋势。而在家中从事副业不仅能够为我们带来额外的收入&#xff0c;更重要的是&#xff0c;它可以让我们在…
阅读更多...
c#中的接口

c#中的接口

使用IEnumerable统一迭代变量类型 class Program {static void Main(string[] args){int[] nums1 new int[] { 1, 2, 3, 4, 5 };ArrayList nums2 new ArrayList { 1, 2, 3, 4, 5 };Console.WriteLine(Sum(nums1));Console.WriteLine(Sum(nums2));Console.WriteLine(Avg(nums…
阅读更多...
ConcurrentHashMap 并发

ConcurrentHashMap 并发

1 ConcurrentHashMap 并发 1.1 减小锁粒度 减小锁粒度是指缩小锁定对象的范围&#xff0c;从而减小锁冲突的可能性&#xff0c;从而提高系统的并发能力。减小锁粒度是一种削弱多线程锁竞争的有效手段&#xff0c;这种技术典型的应用是 ConcurrentHashMap(高性能的 HashMap)类的…
阅读更多...
【分布式计算】二、架构 Architectures

【分布式计算】二、架构 Architectures

1.中心化架构&#xff08;Centralized Architectures&#xff09; 1.1.经典C/S模型 服务器&#xff1a;一个或多个进程提供服务 客户端&#xff1a;一个或多个进程使用服务 客户端和服务器可以在不同的机器上 客户端遵循请求/回复模型 1.2.传统三层视图 用户界面层&#x…
阅读更多...
并查集LRUCache

并查集LRUCache

文章目录 并查集1.概念2. 实现 LRUCache1. 概念2. 实现使用标准库实现自主实现 并查集 1.概念 并查集是一个类似于森林的数据结构&#xff0c;并、查、集指的是多个不相干的集合直接的合并和查找&#xff0c;并查集使用于N个集合。适用于将多个元素分成多个集合&#xff0c;在…
阅读更多...
Python分支结构和循环结构

Python分支结构和循环结构

嗨喽~大家好呀&#xff0c;这里是魔王呐 ❤ ~! python更多源码/资料/解答/教程等 点击此处跳转文末名片免费获取 一.分支结构 分支结构是根据判断条件结果而选择不同向前路径的运行方式&#xff0c;分支结构分为&#xff1a;单分支&#xff0c;二分支和多分支。 1&#xff0…
阅读更多...
No154.精选前端面试题，享受每天的挑战和学习

No154.精选前端面试题，享受每天的挑战和学习

🤍 前端开发工程师（主业）、技术博主（副业）、已过CET6 🍨 阿珊和她的猫_CSDN个人主页 🕠 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 🍚 蓝桥云课签约作者、已在蓝桥云课上架的前后端实战课程《Vue.js 和 Egg.js 开发企业级健康管理项目》、《带你从入…
阅读更多...
关于Java的IO流里面的方法read()的细究

关于Java的IO流里面的方法read()的细究

我们会经常看到上面的代码&#xff0c;很显然read(b)&#xff0c;是把字节读入到b这个字节数组里&#xff0c;然后read()返回一个成功读取的字节长度&#xff0c;如果现在用不带参的read()去一个一个字节的读了&#xff1f;那么len bInput.read()就是把这一个节字读入到len&am…
阅读更多...
消息队列实现进程间通信

消息队列实现进程间通信

write.c #include<myhead.h>typedef struct {long msgtype; //消息类型char data[1024]; //消息正文 }Msg_s;#define SIZE sizeof(Msg_s)-sizeof(long) //消息正文的大小int main(int argc, const char *argv[]) {key_t key; //定义一个键值if((key ftok("./&q…
阅读更多...
【每日一题】种花问题

【每日一题】种花问题

文章目录 Tag题目来源题目解读解题思路方法一&#xff1a;贪心 写在最后 Tag 【贪心】【数组】【2023-09-29】 题目来源 605. 种花问题 题目解读 种花要种在空地&#xff08;没有种过花的位置&#xff09;上&#xff0c;花不能种在相邻位置上否则会抢夺水资源无法正常生长&a…
阅读更多...
统计模型----决策树

统计模型----决策树

决策树 &#xff08;1&#xff09;决策树是一种基本分类与回归方法。它的关键在于如何构建这样一棵树。决策树的建立过程中&#xff0c;使用基尼系数来评估节点的纯度和划分的效果。基尼系数是用来度量一个数据集的不确定性的指标&#xff0c;其数值越小表示数据集的纯度越高。…
阅读更多...
管理与系统思维

管理与系统思维

技术管理者不仅仅需要做事情&#xff0c;还需要以系统思维的方式推动组织变革&#xff0c;从而帮助团队和个人做到更好。原文: Management and Systems Thinking 图片来源: Dall-E "除非管理者考虑到组织的系统性&#xff0c;否则大多数提高绩效的努力都将注定失败。"…
阅读更多...
有效括号——括号的匹配

有效括号——括号的匹配

给定一个只包括 ‘(’&#xff0c;‘)’&#xff0c;‘{’&#xff0c;‘}’&#xff0c;‘[’&#xff0c;‘]’ 的字符串 s &#xff0c;判断字符串是否有效。 有效字符串需满足&#xff1a; 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 每个右括号都有…
阅读更多...
C++ 迭代器（iterator）

C++ 迭代器（iterator）

迭代器介绍 迭代器&#xff08;iterator&#xff09;&#xff1a;容器类型内置的“指针” - 使用迭代器可以访问某个元素&#xff0c;迭代器也能从一个元素移动到另一个元素。 - 有迭代器的类型都拥有 begin 和 end 成员- begin&#xff1a;返回指向第一个元素&#xff08;或字…
阅读更多...
LaTex的学习(学习于b站西北农林科技大学耿楠教授的教学视频)

LaTex的学习(学习于b站西北农林科技大学耿楠教授的教学视频)

目录 一、LaTeX软件的安装与环境配置  1.LaTeX软件texlive的下载  2. texlive的安装 二、用命令行实现LaTeX文档的编写  1.通过命令行演示LaTeX编写的过程  2.将编译LaTeX并生成pdf文件的过程封装成一个bat文件  3.演示一个含有中文的LaTeX文件 三、用TexStudio IDE实…
阅读更多...
性格孤僻怎么办？改变性格孤僻的4种方法

性格孤僻怎么办？改变性格孤僻的4种方法

性格孤僻是比较常见的说法&#xff0c;日常中我们说某人性格孤僻&#xff0c;意思就是这人不太合群&#xff0c;喜欢独来独往&#xff0c;话少&#xff0c;人际关系不太好&#xff0c;其言行往往不符合大众的价值观。从性格孤僻的角度来看&#xff0c;可能跟很多种心理疾病存在…
阅读更多...
布隆过滤器Bloom Filter

布隆过滤器Bloom Filter

本章代码gitee仓库&#xff1a;布隆过滤器 文章目录 0. 前言1. 布隆过滤器的概念2. 布隆过滤器的实现2.1 哈希函数2.2 插入和判断 3. 布隆过滤器的删除4. 布隆过滤器的误判 0. 前言 我们在玩某款游戏的时候&#xff0c;刚注册的话&#xff0c;我们需要取一个昵称&#xff0c;这…
阅读更多...
Kafka：安装与简单使用

Kafka：安装与简单使用

文章目录 下载安装windows安装目录结构启动服务器创建主题发送一些消息启动消费者设置多代理集群常见问题 工具kafka tool 常用指令topic查看topic删除topic 常见问题参考文献 下载安装 下载地址&#xff1a;kafka-download windows安装 下载完后&#xff0c;找一个目录解压…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023