【C语言】文件操作

Hyt的笔记本

已于 2023-08-10 20:33:50 修改

阅读量157

点赞数 5

文章标签： c语言开发语言

于 2023-08-10 01:20:32 首次发布

本文链接：https://blog.csdn.net/weixin_73914025/article/details/132172395

版权

文章目录

1. 为什么使用文件
2. 什么是文件
3. 文件的打开和关闭
4. 文件的顺序读写
- 4.1 顺序读写函数介绍
- 4.2 对比一组函数
5. 文件的随机读写
6. 文本文件和二进制文件
7. 文件读取结束的判定
8. 文件缓冲区

1. 为什么使用文件

我们在程序中操作一些数据时，这些数据是存放在内存中的，当退出程序时，我们对这些数据进行的增删查改的操作就自然不存在了，等下次运行的时候，只能我们自己去重新录入。

所以为了能够方便将数据保存下来，这里涉及到了数据持久化的问题，我们一般数据持久化的方法有：把数据存放在磁盘文件、存放到数据库等方式。

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

2. 什么是文件

磁盘上的文件就是文件

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

程序文件

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

数据文件

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

在前面我们所学的处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
而这章我们将学会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上的文件。

文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：文件路径+文件名主干+文件后缀
例如： c:\code\test.txt
为了方便起见，文件标识常被称为文件名。

3. 文件的打开和关闭

3.1 文件指针

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

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态以及文件当前的位置等）。这个文件信息区也方便我们来管理一个文件。
在这里插入图片描述
这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名FILE。

例如，在VS2022编译环境提供的stdio.h头文件中有以下的文件类型声明：
在这里插入图片描述

不同的C编译器的FILE类型包含的内容可能不完全相同，但都大同小异。每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，我们使用者不必关心细节。

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

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

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

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

比如：
在这里插入图片描述

3.2 文件的打开和关闭

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

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

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

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

打开方式如下：

文件使用方式	含义	如果指定文件不存在
“r”（只读）	为了输入数据，打开一个已经存在的文本文件	出错
“w”（只写）	为了输出数据，打开一个文本文件	建立一个新的文件
“a”（追加）	向文本文件尾添加数据	建立一个新的文件
“rb（只读）	为了输入数据，打开一个二进制文件	出错
“wb”（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
“ab”（追加）	向一个二进制文件尾添加数据	建立一个新的文件
“r+”（读写）	为了读和写，打开一个文本文件	出错
“w+”（读写）	为了读和写，建议一个新的文件	建立一个新的文件
“a+”（读写）	打开一个文件，在文件尾进行读写	建立一个新的文件
“rb+”（读写）	为了读和写打开一个二进制文件	出错
“wb+”（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
“ab+”（读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件

实例代码：

#include <stdio.h>
int main()
{
	FILE* pFile;
	//打开文件
	pFile = fopen("myfile.txt", "w");
	//文件操作
	if (pFile == NULL)
	{
		perror("fopen");
		return -1;
	}
	//操作文件
	fputs("fopen example", pFile);
	//关闭文件
	fclose(pFile);
	pFile = NULL;
	return 0;
}

在这里插入图片描述

3.3 流的概念

我们在之前的学习中，我们都是直接使用printf、scanf等函数在终端设备上进行输入/输出的操作，这是因为：

在C语言程序中，只要运行起来，就会默认打开3个流：

标准文件	文件指针	设备
标准输入	stdin	键盘
标准输出	stdout	屏幕
标准错误	stderr	屏幕

可是我们也不会一直在屏幕或键盘上输出/输出，也可能会从其他外部设备读写数据，这里就要引入一下流的概念了：

当前的计算机具有大量不同的设备，很多都与I/O操作有关。 CD-ROM驱动器、软盘和硬盘驱动器、网络连接、通信端口和视频适配器就是这类很常见的设备。每种设备具有不同的特性和操作协议。操作系统负责这些不同设备的通信细节，并向程序员提供一个更为简单和统一的I/O接口。

ANSI C 进一步对I/O的概念进行了抽象。就C程序而言，所有的I/O操作只是简单地从程序移进或移出字节的事情。因此，毫不惊奇的是，这种字节流便被称为流（stream）。程序只需要关心创建正确的输出字节数据，以及正确的解释从输入读取的字节数据。特定的I/O设备的细节对程序员是隐藏。

绝大多数流是完全缓冲的（fully buffered），这意味着“读取”和“写入”实际上是从一块被称为缓冲区（buffer）的内存区域来回复制数据。从内存中来回复制数据是非常快速的。用于输出流的缓冲区只有当它写满时才会被刷新（flush，物理写入）到设备或文件中。一次性把写满的缓冲区写入和逐片把程序产生的输出分别写入相比效率更高。类似的，输入缓冲区当它为空时通过从设备或文件读取下一块较大的输入，重新填充缓冲区。

使用标准输入和输出时，这种缓冲可能会引起混淆。所以，只有当操作系统可以断定它们与交互设备并无联系时才会进行完全缓冲。否则，它们的缓冲状态将因编译器而异。一个常见（但并不普通）的策略是把标准输出和标准输入联系在一起，就是当请求输入时同时刷新输出缓冲区。这样，在用户必须进行输入之前，提示用户进行输入的信息和以前写入到输出缓冲区中的内容将出现在屏幕上。

4. 文件的顺序读写

4.1 顺序读写函数介绍

功能	函数名	适用于
字符输入函数	fgetc	所有输入流
字符输出函数	fputc	所有输出流
文本行输入函数	fgets	所有输入流
文本行输出函数	fputs	所有输出流
格式化输入函数	fscanf	所有输入流
格式化输出函数	fprintf	所有输出流
二进制输入	fread	文件
二进制输出	fwrite	文件

现在我们来大致演示一下这些函数是怎么用的：

fputc

#include <stdio.h>
int main()
{
	FILE* pf = fopen("date.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//写文件
	int i = 0;
	for (i = 0;i < 26;i++)
	{
		fputc('a' + i, pf);
		//将26个字母写入到"date.txt"文件中
	}

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

当程序成功运行起来以后就会在我们所在的文件夹中创建一个新的文件data.txt：
在这里插入图片描述
里面的内容如图所示：

可以看到，我们成功的将26个小写字母都写入到了data.txt文件中。但有一点需要注意的是，当我们再次以“w”的方式打开该文件并不做什么事的话，里面的数据就会清空了，如图所示：
在这里插入图片描述

fgetc
我们先用上面的代码将26个小写字母读入到data.txt文件中去，再来进行下面的操作：

#include <stdio.h>
int main()
{
	FILE* pf = fopen("date.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//读文件
	int i = 0;
	for (i = 0;i < 26;i++)
	{
		//将data.txt文件中的字符读取出来
		char ch = fgetc(pf);
		//写入到标准输出流--屏幕上
		printf("%c", ch);
	}

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

效果如图所示：
在这里插入图片描述

fputs

#include <stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("date.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//写文件
	fputs("hello life", pf);
	fputs("don't give up", pf);

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

效果如图：
在这里插入图片描述
这里可以看到，它并没有会自动换行，所以我们要想换行的话，应该自己手动换行：在字符串的末尾加一个'\n'：

fgets

#include <stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("date.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//读文件
	char str[30] = { 0 };
	//这里的意思是:从pf所指向的文件中读取最大12个字符(包括终止字符)到数组str中去
	//注:如果要读取的字符串长度大于该函数第二个参数,则最后一位是用来存放'\0'的,
	//所以,我们所能读取的字符串长度是比第二个参数少1的
	fgets(str, 30, pf);
	printf("%s", str);
	//读取完上面的那行,再读下面一行
	fgets(str, 30, pf);
	printf("%s", str);

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

效果如图（⭐️：认真看上面fgets函数的分析）：
在这里插入图片描述

fwrite 和 fread

#include <stdio.h>
struct S
{
	int a;
	float f;
	char* str;
};

#include <stdio.h>
int main()
{
	struct S s = { 0 }; 
	//打开文件
	FILE* pf = fopen("data.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	//写文件
	s.a = 1;
	s.f = 3.14f;
	s.str = "hello";
	//函数fwrite的参数含义:
	//第一个参数:要写入数据的指针
	//第二个参数:要写入的每个元素大小为多少
	//第三个参数:要写入多少个元素
	//第四个参数:要将数据写入到哪里
	//这里的意思是:将&s中，1个大小为sizeof(struct S)的数据写入到pf中
	fwrite(&s, sizeof(struct S), 1, pf);

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这样写的代码是否可行呢？

事实上，我们这段代码是存在问题的，我们是用一个字符指针指向一个字符串，该指针指向的是字符串的首元素地址，也就是h的地址，但在程序运行结束时，我们再重新运行程序去使用fread读取数据，得到的是我们之前存入的内存，这时候，这块内存存放的是什么我们就不得而知了，如图：
在这里插入图片描述
当我们读取文件时得到的其实是我们之前存放的一个地址，所以当我们再次去读取时，得到的也是一个地址，但这个地址我们无法去访问：

正确的做法应该是：

#include <stdio.h>
struct S
{
	int a;
	float f;
	char str[10];
};

#include <stdio.h>
int main()
{
	struct S s = { 1,3.14,"hello"};
	//打开文件
	FILE* pf = fopen("data.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	//写文件
	fwrite(&s, sizeof(struct S), 1, pf);

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

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

当我们再去读取时，读取到的数据就不是一个地址了，而是将这个字符串的内容一个一个的读取下来了
在这里插入图片描述

4.2 对比一组函数

我们上面列举的函数，只有fscanf、fprintf没有讲到，是因为准备放到这里来讲。

我们首先来看一对函数：

scanf / fscanf / sscanf

printf / fprintf / sprintf

通过两组函数的比较，我们可以很好的发现无论是scanf这组函数，还是printf这组函数，另外两个函数都比它们多出一个参数：
在这里插入图片描述

在这里插入图片描述
我们知道，printf是将数据写入到标准输出流（屏幕）上，而fprintf比printf多出一个参数，表示可以将数据写入到任意文件流上。

scanf是从标准输入流（键盘）中读取数据的，而fscanf比scanf多出一个参数，就表示可以从任意文件流中读取数据，这里看不懂fscanf中的写法，可以参考这篇文章《输入缓冲区》：
在这里插入图片描述

我们再来看sprintf比printf多出的那个参数是一个字符串，根据我们的理解，那应该就是将数据写入到一个字符串中，而sscanf的作用应该是读取一个字符串中的数据：

#include <stdio.h>
struct S
{
	int a;
	float f;
	char str[30];
};

int main()
{
	char arr[40] = { 0 };
	struct S s = { 100,3.14f,"Are you happy today ?" };
	struct S tmp = { 0 };

	//将结构体变量s的数据写入到arr数组中
	sprintf(arr, "%d %f %s", s.a, s.f, s.str);

	//从arr中读取上面写入的数据到结构体变量tmp中
	sscanf(arr, "%d %f %[^\n]", &(tmp.a), &(tmp.f), &(tmp.str));

	//将读取到的数据打印到屏幕上
	printf("%d %f %s", tmp.a, tmp.f, tmp.str);
	return 0;
}

结果如图所示：
在这里插入图片描述

📖：所以在这里总结一下

scanf 从标准输入流读取格式化的数据
printf 向标准输出流写入格式化的数据

fscanf 适用于所有输入流的格式化输入函数
fprintf 适用于所有输出流的格式化输出函数

sscanf 从字符串中读取格式化的数据
sprintf 将格式化的数据写入到字符串中

5. 文件的随机读写

5.1 fseek

函数fseek的原型如下：

int fseek ( FILE * stream, long int offset, int origin );

根据文件指针的位置和偏移量来定位文件指针
第一个参数是要定位的文件指针
第二个参数是从起始位置的偏移量
第三个参数是起始位置

在这里插入图片描述

一个🌰：

#include <stdio.h>
int main()
{
	FILE* pFile = fopen("example.txt", "w");
	if (pFile == NULL)
	{
		perror("fopen");
		return -1;
	}
	//写文件
	fputs("This is an apple.", pFile);//将该字符串写入到文件中
	fseek(pFile, 9, SEEK_SET);//找到从文件起始位置偏移量为9的地方
	fputs(" sam", pFile);//从文件偏移量为9的地方写入这个字符串
	
	//关闭文件
	fclose(pFile);
	pFile = NULL;
	return 0;
}

在这里插入图片描述

5.2 ftell

函数ftell的原型如下：

long int ftell ( FILE * stream );

返回文件指针相对于起始位置的偏移量

一个🌰：

#include <stdio.h>
int main()
{
	long size = 0;
	FILE* pFile = fopen("data.txt", "rb");
	if (pFile == NULL)
	{
		perror("Error opening file");
		return -1;
	}
	//将文件指针定位到文件末尾偏移0的位置处,也就是定位到文件末尾
	fseek(pFile, 0, SEEK_END);
	//size = 文件中的字符个数
	size = ftell(pFile);
	fclose(pFile);
	pFile = NULL;
	printf("Size of myfile.txt: %ld bytes.\n", size);
	
	return 0;
}

效果如图所示：
在这里插入图片描述

5.3 rewind

函数rewind的原型如下：

void rewind ( FILE * stream );

让文件指针的位置回到文件的起始位置

一个🌰：

#include <stdio.h>
int main()
{
	int n;
	char buffer[27];
	FILE* pFile = fopen("myfile.txt", "w+");
	if (pFile == NULL)
	{
		perror("fopen");
		return -1;
	}
	for (n = 'A'; n <= 'Z'; n++)
		fputc(n, pFile);//将26个大写字母写入到文件中
	rewind(pFile);//让文件指针回到起始位置
	fread(buffer, 1, 26, pFile);//读取26个大写字母到buffer中
	fclose(pFile);
	pFile = NULL;
	buffer[26] = '\0';
	puts(buffer);//将buffer中的内容打印到屏幕上
	return 0;
}

效果如图：
在这里插入图片描述

6. 文本文件和二进制文件

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

通俗点说：我们能够看得懂的就是文本文件，我们看不懂的就是二进制文件

一个数据在内存中是怎样存储的呢？

字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节。如图：
在这里插入图片描述

我们来测试一下：

#include <stdio.h>
int main()
{
	int a = 10000;
	FILE* pf = fopen("test.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
	fclose(pf);
	pf = NULL;
	return 0;
}

然后我们进行以下操作：
在这里插入图片描述
然后可以看到我们将10000转换成二进制的形式存储形式：

7. 文件读取结束的判定

函数feof的原型如下：

int feof ( FILE * stream );

当文件读取结束的时候，判断读取结束的原因是否为：遇到文件末尾

牢记：在文件读取过程中，不能用feof函数的返回值直接来判断文件是否结束（因为导致文件结束还有可能是因为发生错误）

函数ferror的原型如下：

int ferror ( FILE * stream );

当文件读取结束的时候，判断读取结束的原因是否为：发生错误

那么我们应该怎么去判断文件是否读取结束呢？

文本文件读取是否结束，判断返回值是否为EOF（fgetc），或者NULL（fgets）
- fgetc判断是否为EOF
- fgets判断返回值是否为NULL
二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
- fread判断返回值是否小于实际要读的个数。
- fread的返回值是成功读取的元素总数。如果此数字与第三个参数（size_t count）不同 ，则表示发生读取错误，或者读取时已到达文件末尾。在这两种情况下，都设置了正确的指示符，可以分别使用ferror和feof进行检查

文本文件的🌰：


#include <stdio.h>
#include <stdlib.h>
int main(void)
{
	int c; 
	FILE* fp = fopen("data.txt", "r");
	if (!fp) 
	{
		perror("File opening failed");
		return -1;
	}
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环
	{
		putchar(c);
	}
	printf("\n");//读取完字符换行
	//判断是什么原因结束的
	if (ferror(fp))
		puts("I/O error when reading");
	else if (feof(fp))
		puts("End of file reached successfully");
	fclose(fp);
	fp = NULL;
}

效果如图所示：
在这里插入图片描述

二进制文件的🌰：

#include <stdio.h>
//定义一个枚举常量
enum { SIZE = 5 };

int main()
{
	double a[SIZE] = { 1.,2.,3.,4.,5. };
	//打开文件
	FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式
	if (fp == NULL)
	{
		perror("fopen");
		return -1;
	}
	//写入文件
	fwrite(a, sizeof(*a), SIZE, fp); // 写 double 的数组
	//关闭文件
	fclose(fp);
	fp = NULL;

	double b[SIZE];
	//打开文件
	fp = fopen("test.bin", "rb");
	if (fp == NULL)
	{
		perror("fopen");
		return -1;
	}
	//读取文件
	size_t ret_code = fread(b, sizeof * b, SIZE, fp); // 读 double 的数组
	if (ret_code == SIZE) //数组成功读取内容
	{
		puts("Array read successfully contents: ");
		for (int n = 0; n < SIZE; ++n) 
			printf("%f ", b[n]);
		putchar('\n');
	}
	else // error reason
	{ 
		if (feof(fp))
			printf("Error reading test.bin: unexpected end of file\n");
		else if (ferror(fp)) {
			perror("Error reading test.bin");
		}
	}
	//关闭文件
	fclose(fp);
	fp = NULL;
	return 0;
}

效果如图所示：
在这里插入图片描述

8. 文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的

在这里插入图片描述

我们来看一个函数：fflush它的原型如下：

int fflush ( FILE * stream );

这个函数可以刷新缓冲区，将缓冲区的内容直接送到程序数据区或者硬盘中（不用等到数据充满缓冲区）。

我们可以写个程序判断缓冲区的存在：

#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	fputs("abcdef", pf);//先将代码放在输出缓冲区
	printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
	Sleep(10000);
	printf("刷新缓冲区\n");
	fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
	printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
	Sleep(10000);
	fclose(pf);
	//注：fclose在关闭文件的时候，也会刷新缓冲区
	pf = NULL;
	return 0;
}

我们可以看到，当我们开始运行程序时，因为使用了暂停函数Sleep，所以开始并没有数据写入到文件中：
在这里插入图片描述
等待十秒以后，因为fflush函数，使缓冲区刷新，数据写入到文件中

此时程序还没有结束，还要等待十秒（因为文件关闭时也会刷新缓冲区，这里我们要验证是否是fflush刷新的缓冲区，所以再等待十秒让我们观察）
在这里插入图片描述

所以这里可以得到一个结论：

因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件时发生问题

Hyt的笔记本

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
2
评论
【C语言】文件操作

磁盘上的文件就是文件但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度分类的）。程序文件包括源程序（后缀为.c），目标文件（Windows环境后缀为.obj），可执行程序（Windows环境后缀为.exe）.数据文件文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。在前面我们所学的处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
复制链接

扫一扫