【C语言】内存管理&&内存管理函数&&文件管理&&文件管理函数

最新推荐文章于 2024-05-16 01:11:39 发布

醋溜马桶圈

最新推荐文章于 2024-05-16 01:11:39 发布

阅读量1.1k

点赞数 27

分类专栏： # C语言文章标签： c语言 java 开发语言

本文链接：https://blog.csdn.net/m0_74722801/article/details/136905165

版权

C语言专栏收录该内容

7 篇文章 0 订阅

订阅专栏

主页：醋溜马桶圈-CSDN博客

专栏：C语言_醋溜马桶圈的博客-CSDN博客

gitee：mnxcc (mnxcc) - Gitee.com

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

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

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

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

1.C/C++程序的内存开辟

前面我们说过，计算机中内存分为三个区域：栈区，堆区，静态区

但是这只是个简化的版本，接下来我们仔细看看内存区域的划分

C/C++程序内存分配的几个区域：

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

实际上普通的局部变量是在栈区分配空间的，栈区的特点时在上面创建的变量出了作用域就销毁

但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以生命周期变长

2.内存相关的函数

2.1 memcpy

2.1.1 memcpy函数的使用

strcpy函数我们可能都知道，字符串拷贝函数，跟函数名一样，只能拷贝字符串

但是我们知道，内存中的数据不仅仅是字符

int arr1[10] = { 0 };
int arr2[] = { 1,2,3,4,5 };

比如，当我们有这么一段数据

我们需要把arr2中的前五个整型的数据拷贝放在arr1中

这个时候我们就不能使用strcpy，因为他是整型数据了

这时候我们C语言就提供了memcpy函数，同样的，我们在Reference - C++ Reference (cplusplus.com)上学习一下该函数

void * memcpy ( void * destination, const void * source, size_t num );

我们可以理解为，把source中的前num个字节的数据拷贝放到destination中去

我们还是用监视窗口来看一下数据是否被拷贝

我们可以看到确实是被拷贝过去了

2.1.2 memcpy函数的模拟实现

void* my_memcpy(const void* dest, const void* src, size_t sz)
{
	assert(dest && src);
	while (sz--)
	{
		*(char*)dest = *(char*)src;
		dest=(char*)dest+1;
		src=(char*)src+1;
	}
}

运行的结果也是同样的效果

这里我们要注意

void*是不能直接++和--的，所以我们需要强转为char*类型，++或--跳过一个字节的空间

void*是不能直接解引用的，所以我们需要强转为char*类型，解引用

2.2 memmove

2.2.2 memcpy存在的局限性

我们这个代码也是存在一定的局限性，比如下面这种情况

将数组arr的前五个数据拷贝到arr[2]的位置，通过调试我们发现写出来的函数并不能有效的实现

C语言的标准规定：

不重叠内存的拷贝，可以使用memcpy，重叠内存的拷贝就不能使用了

重叠内存的拷贝，我们可以使用memmove函数来实现

2.2.2 memmove函数的使用

同样的，我们来先学习一下memmove函数的使用

void * memmove ( void * destination, const void * source, size_t num );

他的参数和返回类型和memcpy一模一样，

我们尝试使用一下memmove函数，看能否解决刚才的问题

这样问题就很好的解决了

2.2.3 memmove函数的模拟实现

#include <stdio.h>
#include<string.h>
#include<assert.h>
void* my_memmove(const void* dest, const void* src, size_t sz)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		//前->后
		for(int i=0;i<sz;i++)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (sz--)
		{
			*((char*)dest + sz) = *((char*)src+sz);
			/*dest = (char*)dest - 1;
			src = (char*)src - 1;*/
		}
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1+2, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	my_memmove(arr2 , arr2+2, 20);
	for (int j = 0; j < 10; j++)
	{
		printf("%d ", arr2[j]);
	}
	return 0;
}

这样我们的代码就能实现memmove的效果了

2.3 memset

2.3.1 memset函数的使用

void * memset ( void * ptr, int value, size_t num );

memset函数是以字节为单位设置内存的函数

将 ptr 指向的内存块的第1个字节(num)数设置为指定值（value）

举个例子

2.4 memcmp

2.4.1 memcpy函数的使用

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

memcmp函数作用是比较ptr1和ptr2指向的内存空间的前num个字节的数据

如果相同则返回0
如果ptr1指向内存的数据是小于ptr2指向内存的数据的，则返回小于0的数字
否则返回大于0的数字

memcmp比较是以字节为单位比较的

举个例子

3.动态内存管理

3.1 为什么存在动态内存分配？

2种申请内存的方式：

一次开辟一个变量的空间
一次开辟一个数组的空间

int main()
{
    int a = 10;//存放一个值
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//存放一组值
    return 0;
}

但是他们都存在一个问题：空间一旦申请好，大小就是固定的，不能改变

所以C语言给了我们一种权利，能够动态申请和管理内存空间

3.2 动态内存函数的介绍

3.2.1 malloc

C语言提供了一个能够动态内存开辟的函数：

void* malloc(size_t size);

我们可以在cplusplus网站来查看一下这个函数：

malloc - C++ Reference (cplusplus.com)

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针

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

那么怎么使用这个函数呢，我们举个例子;

malloc需要包含的头文件是stdlib.h

如果申请失败就会这样：

如果返回了NULL指针，则不能使用了

从这个图可以看出

动态内存的管理都是在堆区进行的

假设我们要使用这块内存

malloc申请的空间是怎么释放的呢？

free释放，主动释放
程序退出后，malloc申请的空间，也会被操作系统回收的

free

malloc函数是用来申请空间的，这块空间使用完之后还是需要释放

C语言中提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

void free(void* ptr);

同样我们先认识一下这个函数free - C++ Reference (cplusplus.com)

free函数用来释放动态开辟的内存

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

free也声明在stdlib.h头文件中

为了防止成为空指针，我们free之后需要把这个指针置空

3.2.2 calloc

在C语言中，还提供了一个函数叫calloc，calloc函数也用来动态内存分配，原型如下：

void* calloc (size_t num, size_t size);

同样，我们认识一下这个函数calloc - C++ Reference (cplusplus.com)

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

和malloc对比：

这是malloc开辟的空间（不会初始化）

这是calloc开辟的空间（初始化为0）

如果我们对申请的内存空间的内容要求初始化，那么就可以很方便的使用calloc函数来完成任务

3.2.3 realloc

realloc函数的出现让动态内存管理更加灵活
realloc函数可以做到对动态开辟内存大小的调整

函数原型如下：

void* realloc (void* ptr, size_t size);

realloc - C++ Reference (cplusplus.com)

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

realloc开辟空间也可能会失败，失败的时候返回NULL

realloc在调整内存空间的时候存在两种情况：

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

3.3 常见的动态内存错误

3.3.1 对NULL指针的解引用操作

不做返回值判断，就可能使用NULL指针

所以我们在使用的时候，一定要判断返回值

if (p == NULL)

动态开辟的内存也是有范围的

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

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

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

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

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

4.C语言文件操作

4.1 为什么使用文件

程序运行起来的时候，程序中的数据都是放在内存中

如果要保存这些数据，不至于丢失，我们可以使用文件保存信息

使用文件我们可以将数据直接存放到电脑的硬盘上，做到了数据的持久化

4.2 什么是文件

磁盘上的文件是文件

但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度分类）

4.2.1 程序文件

包括源程序文件（后缀为.c），目标文件（windows环境环境后缀为.obj）,可执行程序（windows环境后缀为.exe）

4.2.2 数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件

接下来我们讨论数据文件

在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上

其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件

4.2.3 文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。

文件名包含三部分：文件路径+文件名主干+文件后缀

例如： c:\code\test.txt

为了方便起见，文件标识常被称为文件名

4.3 文件的打开和关闭

4.3.1 文件指针

缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）

这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE

例如，VS2013编译环境提供的 stdio.h 头文件中有以下的文件类型申明：

struct _iobuf {
        char *_ptr;
        int   _cnt;
        char *_base;
        int   _flag;
        int   _file;
        int   _charbuf;
        int   _bufsiz;
        char *_tmpfname;
       };
typedef struct _iobuf FILE;

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异

每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节

一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便

下面我们可以创建一个FILE*的指针变量:

FILE* pf;//文件指针变量

定义pf是一个指向FILE类型数据的指针变量，可以使pf指向某个文件的文件信息区（是一个结构体变量），通过该文件信息区中的信息就能够访问该文件

也就是说，通过文件指针变量能够找到与它关联的文件

4.3.2 文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件

在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系

ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件

//打开文件
FILE * fopen ( const char * filename, const char * mode );
//关闭文件
int fclose ( FILE * stream );

打开方式如下：

4.3.3 fopen函数

我们学习一下fopen函数fopen - C++ Reference (cplusplus.com)

我们总结出来了一些文件的打开方式：

打开文件的基本操作：

如果没有该文件，则返回一个NULL指针，返回一个错误

4.3.4 fclose函数

我们学习一下fclose函数fclose - C++ Reference (cplusplus.com)

为了防止pf成为野指针，这里我们把它置为空指针

fopen和fclose函数跟动态内存开辟有相似的地方：他们都是对资源的管理和使用

运行刚刚的代码，我们发现在这个文件的地址下，就生成了data.txt 文件

这里我们还要了解一下绝对路径和相对路径的概念

相对路径：

. 表示当前路径

.. 表示上一级路径

举例说明一下：

绝对路径：

举例说明：

4.4 文件的顺序读写

4.4.1 顺序读写函数介绍

fgetc和fputc函数

fputc - C++ Reference (cplusplus.com)

fgetc - C++ Reference (cplusplus.com)

使用一下fputc函数：

4.4.2 输入流和输出流

其实我们在写文件的时候，打开文件、关闭文件

scanf从键盘上读取数据

printf向屏幕上打印数据

直接就操作了，这是因为：C语言程序，只要运作起来，默认就打开了三个流

标准输入流 - stdin
标准输出流 - stdout
标准错误流 - stderr

4.4.3 对比一组函数

对比scanf和printf函数

scanf 是格式化的输入函数，针对的是标准输入流（键盘）
printf 是格式化的输出函数，针对的是标准输出流（屏幕）
scanf和printf是针对标准输入/输出流的格式化输入/输出函数
fscanf 是针对所有输入流（文件流、标准输入流）的格式化输入函数
fprintf 是针对所有输出流（文件流、标准输出流）的格式化输出函数
sscanf 将字符串转换成格式化的数据
sprintf 将格式化的数据转换成字符串