C语言进阶学习笔记五动态内存分配(爆肝吐血力作,强烈建议收藏!!!)

Posted 大家好我叫张同学

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C语言进阶学习笔记五动态内存分配(爆肝吐血力作,强烈建议收藏!!!)相关的知识,希望对你有一定的参考价值。

前言

现代计算机基本都是基于冯诺伊曼结构体系设计出来的,冯诺伊曼结构体系的核心就是“存储程序”,将程序(指令集)和数据以同等地位存储在内存中。但是我们的内存空间并不是无限大的,所以为了高效的利用好内存空间,操作系统会对这些内存空间进行相应的分区,不同区域的内存有其对应的功能和使用方式。

比如局部变量、函数形参通常是存储在栈区的,这部分内存空间的特点就是临时使用,用完即释放(当然这个都是由操作系统自动完成的,不需要程序员的干预);
再比如全局变量通常存放在静态区,此外由static修饰的局部变量也会放到静态区(所以static修饰局部变量,本质上是改变了其存储的位置,从栈区-- > 静态区),这部分内存空间就是生命周期很长,长到整个程序运行结束;
再例如我们使用的常量字符串,会被保存到常量区,这部分内存区域的特点就是类似于“常量”,不可被修改,相当于添加了一个“const”的buff。
(我的废话:在学习的时候如果可以多多思考,联系不同的知识点,当将这些内容串起来时,可以形成一个比较宏观、整体的角度。更进一步,如果我们能够从中找到乐趣就更好了!现在我们进入正题吧!)


全文结构:


一、寻根问底

什么是动态内存分配 / 管理?

由程序员根据实际编程需要向操作系统申请,在堆区上开辟的,供程序员操作使用和维护的内存空间,程序员的游乐园!通常是一些临时用到的数据或者变量,随时开辟,用完随时释放,而不必等到函数结束后由操作系统回收!

为什么需要动态内存分配?

实际编程中,不仅需要大小固定的内存空间,往往还需要大小可变的内存空间。
比如说如果我们要建立一个通讯录,用来存放相关信息(姓名、性别、年龄、电话等),这种复杂的数据,我们知道要用结构体类型来存储,而且要用结构体数组来存,但是问题是“这个数组的大小应该多大呢?”
这个问题确实不好回答,如果长度给小了,那么就会导致数据溢出,进而引发程序崩溃。
如果给大了,又会导致存储空间大量浪费,空间利用率低。
为了解决这一类问题,就出现了动态内存分配,内存空间按需索取,要多少给多少!

怎么建立动态内存分配?

通过系统提供的4个库函数实现,malloc\\calloc\\realloc\\free,这四个函数后面我们会详细介绍。


二、动态内存函数

注意:以下说的四个函数的头文件均为:stdlib.h

malloc

函数原型:void * malloc(size_t size);

size_t就是unsigned int(无符号整型)

这个函数的作用就是在动态存储区中分配一个长度为size个字节的连续空间,并返回指向该空间的指针。

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

动态开辟的空间如何释放和回收呢?
C语言提供了一个专门完成这个功能的库函数-- - free


free

函数原型:void free(void* p)

free的作用就是释放指针变量p所指向的动态空间,使这部分空间能够重新被利用。

1)如果参数ptr指向的空间不是动态开辟的,那free函数的行为是未定义的。
2)如果参数 ptr是NULL指针,则函数什么事都不做。


现在来看一下实际的使用:

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//1.通过动态开辟申请10个int类型的空间
	int* ptr = (int*)malloc(10 * sizeof(int));//通常结合sizeof一起使用
	//根据实际使用强制类型转换为想要的类型
	//2.malloc有可能申请空间失败,所以需要判断一下
	if (ptr == NULL)
	{
		perror("main");//perror是一个报错函数,实际出错时打印效果为:main:xxxxxx(错误原因)
		return 0;//出错就直接结束函数
	}
	//3.使用 给这10个整型空间赋值
	for (int i = 0; i < 10; i++)
	{
		*(ptr + i) = i;
	}
	//打印一下
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ptr[i]);//这里可以直接使用数组下标的形式,和指针解引用是一样的
	}
	//4.释放
	free(ptr);
	ptr = NULL;//需要手动置为NULL,防止非法访问
	return 0;
}

注意: 用malloc申请的空间,里面的内容是随机值,如果不初始化的话,可能就会得到一些意想不到的值;

理解:如果参数ptr指向的空间不是动态开辟的,那free函数的行为是未定义的。


为什么要进行动态内存的释放和回收?

内存空间是有限的,如果我们每次在使用的时候只是一味的向申请空间,即使空间再大,也会被用完,而且如果使用的空间不释放会导致电脑越来越卡,程序运行越来越慢!

那释放之后为什么要手动将指针赋值为NULL(空指针)呢?

举一个生活中的例子吧,假设有一个男生跟他女朋友分手了,如果这个男生还一直保留这个女生的电话、微信,更有甚者,还有这个女生家里面的钥匙。如果你是这个女生的话,你希望他仍然保留这些信息和物品吗?你肯定是不想对吧,指不定哪一天他不高兴或者其它原因就来骚扰你。(所以才会有一句话叫做情侣分手千万不要藕断丝连,当然如果你是这个男生的话,你可能还想着以后和好如初,念念不忘,必有回响~haha)。
言归正传,编程中如果指针指向的空间已经被释放了,如果不将其置为NULL,那么其仍然保留这个地方的地址,之后仍然有可能访问到这片空间,这个生活就是非法访问了!

那有没有动态分配函数在申请空间的同时就进行初始化呢 ?

答案当然是有,接下来要结束的calloc就是这样的一个函数


calloc

函数原型:void * calloc(size_t num, size_t size);

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

比如刚刚的上面的代码,如果我们将malloc换成calloc,不进行手动初始化:

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)calloc(10, sizeof(int));
	if (ptr == NULL)
	{
		perror("main");
		//perror是一个报错函数,实际出错时打印效果为:main:xxxxxx(错误原因)
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ptr[i]);
	}
	free(ptr);
	ptr = NULL;
	return 0;
}


光从上面这三个函数的介绍,我们可能并没有深刻体会到“动态内存分配”的动态体现在哪,接下来要介绍的函数才是动态内存分配的“灵魂”-- - realloc


realloc

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

函数原型:void * realloc(void* ptr, size_t size);

1)ptr是要调整的内存地址.size是调整之后新大小
2)返回值为调整之后的内存起始位置
3)这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间。(这种移动的方式实际上就是复制拷贝,会将原内容复制拷贝到新内存中)
4)realloc在调整内存空间的是存在两种情况︰
情况1∶原有空间之后有足够大的空间
情况2︰原有空间之后没有足够大的空间

当是情况1的时候,要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化。
当是情况2的时候,原有空间之后没有足够多的空间时,扩展的方法是∶在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

由于上述的两种情况,realloc函数的使用就要注意一些。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(10 * sizeof(int));
	if (ptr == NULL)
	{
		perror("main");
		return 0;
	}
	//业务处理
	//进行扩容操作
	int* p = (int*)realloc(ptr, 100 * sizeof(int));
	//注意:不能直接将扩容之后的地址给ptr,因为存在扩容失败的可能,会导致ptr地址丢失
	if (p == NULL)
	{
		printf("raalloc failed!\\n");
		return 0;
	}
	ptr = p;
	//业务处理
	free(ptr);
	ptr = NULL;
	return 0;
}

三、常见的动态内存错误

1)对空指针NULL的解引用操作

void test()
{
	//int* p = NULL;
	int* p = (int*)malloc(INT_MAX);
	*p = 20;//如果p的值为NULL,就会出问题
	free(p);
}

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


当I = 10时越界访问


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


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


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


6)动态开辟内存忘记释放(导致内存泄露)

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


四、柔性数组

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

其实从名字我们也可以大概知道其含义,“柔性”指柔软的,可变动的,flexible 本就具有灵活的,可变的含义。

举例:

struct S
{
	int n;
	int arr[];//还可以写成这样 int arr[0];
};

柔性数组的特点∶
1)结构中的柔性数组成员前面必须至少一个其他成员。(也就是说柔性数组成员不能单独存在)
2)sizeof返回的这种结构大小不包括柔性数组的内存。(计算大小的时候,不考虑柔性数组成员的大小)

3)包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。(也就是包含柔性数组成员的结构体类型在创建变量的时候,需要用动态内存开辟的方式来创建。原因是:柔性数组的大小可变,那么其创建出来的结构体变量大小也是可变的,所以需要动态开辟的方式来创建!)

举例:

#include<stdio.h>
struct S
{
	int n;
	int arr[];//还可以写成这样 int arr[0];
};
int main()
{
	//struct S s1;这种方式创建的变量无法正常使用
	//printf("%d\\n", sizeof(s1));
	//假设我们期望arr的大小是10个int类型
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	return 0;
}

动态开辟内存分布情况如图:

正因为空间是动态开辟出来的,如果后续使用的时候,数组arr的空间大小不够了,可以通过realloc去动态调整,体现了其“柔性”的特点。


完整的代码:

#include<stdio.h>
struct S
{
	int n;
	int arr[];//还可以写成这样 int arr[0];
};
int main()
{
	//假设我们期望arr的大小是10个int类型
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	ps->n = 10;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	//调整
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr == NULL)
	{
		perror("main");
		return 1;
	}
	ps = ptr;
	//使用
	//.....
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

柔性数组功能的替代方法
用一个指针代替柔性数组成员

struct S
{
	int n;
	//int arr[];//还可以写成这样 int arr[0];
	int* arr;//替换柔性数组
};

柔性数组与非柔性数组比较

好处一:方面内存释放
如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。
好处二 : 这样有利于访问速度.
连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)
(涉及到内存池,局部性原理:空间局部性原理、时间局部性原理,有兴趣的同学可自行查找资料!)


回顾:

以上是关于C语言进阶学习笔记五动态内存分配(爆肝吐血力作,强烈建议收藏!!!)的主要内容,如果未能解决你的问题,请参考以下文章

C语言进阶—— 字符操作函数+内存操作函数详解 (吐血爆肝 !!!)

C语言进阶学习笔记三字符串函数+内存函数详解

C语言学习笔记--动态内存分配

C语言学习笔记(16)动态内存管理

[C语言学习笔记]--动态内存管理

C语言进阶四.动态内存管理