C语言版的文件操作看这一篇就足够了！详解~

最新推荐文章于 2023-10-26 15:20:45 发布

困的睡不着.

最新推荐文章于 2023-10-26 15:20:45 发布

阅读量237

点赞数 1

文章标签： c语言程序人生

本文链接：https://blog.csdn.net/lf040629/article/details/133893408

版权

1.文件是什么？使用文件有什么好处？

磁盘上存储数据的载体就是文件。而我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。
使用文件我们可以将数据直接存放在电脑的硬盘上，做到数据的持久化。这就是使用文件的好处。

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

2.文件的打开与关闭

原来文件可以帮助我们实现数据的持久化，那我们应该如何在程序中对文件进行操作呢？很简单，不知道大家有没有看过春晚宋丹丹和赵本山老师演的小品，其中有一句经典台词，“把大象装进冰箱需要几步？” 答：三步“ 首先，打开冰箱门，其次，把大象装进去，最后，关闭冰箱门”，就这么简单，而文件的操作也是一样需要三步，首先，把文件打开，然后，对文件中的数据进行我们需要的操作，最后，关闭文件，退出程序~听起来是不是很简单呢？

2.1文件的打开

文件的打开用fopen函数完成，他这个函数有两个参数，第一个参数是指文件的名称，第二个是指打开文件的方式。

看到这里，有人心中不免会有疑问，一个文件夹里可能会出现很多类型的文件啊，这些文件可能是重名的，那我们怎么区分呢? 这就得说说文件名的构成了，文件名由文件路径+文件名主干+文件后缀构成，文件名也叫文件标识，例如： c:\code\test.txt，这里的c:\code\就叫文件路径 test就叫文件名主干，.txt就是文件后缀~

所以我们需要在文件名上标注文件位置也就是文件路径，而文件路径分为两种，一种是相对路径，一种是绝对路径，请看以下代码：

FILE* pf = fopen("data.txt","w");//相对路径 默认同一级 
//FILE* pf = fopen(".\..\\data.txt", "w");//上一级 打开失败
//FILE* pf = fopen("D:\\比特就业课C语言\\C语言每天Code\\2023-c-language-learning\\文件操作\\文件操作\\data.txt", "w");//绝对路径
//	//.表示当前路径   ..表示上一级  注意转义字符！

由此我们可以得出，相对路径是默认从可执行程序这一级开始查找，相对简单，绝对路径比较长，相对复杂。

再来看fopen函数的第二个参数，const char* mode ，mode模式，由此可以推断出第二个参数决定了文件以什么样的模式打开，换言之就是文件接下来要进行什么样的操作~

这里给出一些常见的操作列表~

这两个参数都是字符串的形式，不能出错，否则程序一定出错！

fopen函数的返回类型是FILE* ，也就是文件指针，那这个指针指向的是文件本身吗？并不是！这里我们引入文件信息区的概念~

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE。
例如，VS2013编译环境提供的stdio.h头文件中有以下的文件类型申明：

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。
每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息,使用者不必关心细节。定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。所以我们知道了，fopen返回的是系统自动创建的文件信息区的地址，需要用一个文件指针变量来接收，即FILE * 。

而在使用完fopen函数后，为了保证我们确实打开了这么一个文件，我们判断他是否是非空指针，否则报错

2.2 文件的关闭

关闭文件使用的是 fclose函数 // int fclose ( FILE * stream );

需要注意的是，fclose函数将形参中传递的文件指针指向的文件流关闭后，不会将其地址置空，所以pf指针还会访问到他所保存的内存中的地址，这是不安全的，会形成野指针，所以我们应在fclose函数后手动置空~例如：

3.文件的顺序读写

3.1 文件的字符输入输出函数

fputc是字符输出函数，也就是“写”一个字符进入我们想要的文件中

由这个函数的定义可知，第一个形参是要写的字符，第二个字符是写入的目标流，如果成功则返回写入字符的ASCII码值，否则返回EOF，请看以下示例：

int main() {
	//打开文件
	FILE* pf = fopen("data.txt","w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//操作文件
	//放置abcdef
	int ch = 'a';
	for (int i = 0; i < 6; i++)
	{
		//int fputc ( int character, FILE * stream );
		//成功返回放入字符的ascii码值 不成功返回EOF
		fputc(ch, pf);//fputc就是把一个字符写到pf指向的文件中去
		ch++;
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

成功把“abcdef”六个字符放进目标文件。

同时我们也注意到，如果fputc函数使用于所有输出流，也就是说它不仅可以对上述文件流进行操作，还可以对C语言默认打开的标准输出流（默认屏幕）进行操作：

//对屏幕 也就是标准输出流使用fputc函数
int main() {
	FILE* pf = fopen("data.txt","w");
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	int ch = 'a';
	for (int i = 0; i < 6; i++)
	{
		fputc(ch,stdout);//standard output 标准输出流（屏幕）
		ch++;
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

打印结果：

与之对应的是，fgetc函数，也就是字符输入函数，他是从目标流中读进一个字符，如果成功读进一个字符，则返回这个字符的ASCII码值，不成功则返回EOF～就比如我们读取以下刚才写进的字符串＂ａｂｃｄｅｆ＂，并把它打印在屏幕上：

int main() {
	//打开文件
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int ch = 0;
	//读写文件
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c ", ch);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

打印成功

看到这,我们心里可能会有这样的疑问,如果一个文件中由多个字符,那我们应该读取哪个呢?答案已经不言而喻,因为我们是顺序读写,所以是按照顺序读写字符,而这就需要一个文件指针来完成,这个文件指针类似于光标,当他读或写完一个数据后,自动跳到下一个位置,不用我们手动更改,十分方便~

3.2 文件的文本行输入输出函数

文件的文本行输出函数是fputs函数,看他的名字就知道,他是按照文本中的一行来输出数据的:

//int fputs(const char* str, FILE* stream);
//成功返回非负值  失败返回EOF
int main() {
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	char arr[] = "abc\n";
	fputs(arr, pf);
	fputs("ok\n",pf);

	fclose(pf);
	pf = NULL;
	return 0;
}

根据代码,我们推测先把abc写入文件,然后换行,再把ok写入文件

与之对应的自然就是,fgets函数,从文件中获取一行数据并把它存放到目标指针中去

由其声明可知,该函数可以指定读取数据的个数,如果Num 大于读取到的字符数,那就全部读取,反之就部分读取,最后若成功则返回得到的文本行的首地址.

int main() {
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	char a[20] = { 0 };
	fgets(a,5,pf);
	//pf中的内容是abc\nok\n 而a中存放的是abc 所以fgets函数不会读取换行的内容
	printf(a);
	
	fclose(pf);
	pf = NULL;
	return 0;
}

而对于以上代码,屏幕打印出abc,可得当fgets遇到换行符时就会停止,不会读取下一行也就是换行后的内容~,但与gets()函数不同的时,fgets函数会把得到的换行符\n丢掉,而fgets不会,他会把换行符\n放进去再补\0~

详情请看这个大佬的博客（虽然有点小错误，但总体还是不错的）:fgets函数及其用法，C语言fgets函数详解-CSDN博客

3.3 文件的格式化输入输出函数

fprintf是格式化输出函数，它和printf函数很像，不过fprintf函数适用范围更广，它可以适用于所有输出流，可以把格式化的数据写入文件中~，代码如下：

//int fprintf ( FILE * stream, const char * format, ... );
struct S{
	int age;
	float a;
	char b;
}s;
int main() {
	FILE* pf = fopen("data.txt","w");//r和w每次写的时候不小心写反会发生什么？
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	s.age = 10;
	s.a = 1.1f;
	s.b = 'c';
	struct S s2 = { 0 };
	fprintf(pf, "%d-%f-%c", s.age, s.a, s.b);
	对应的 把文件中的数据以格式化的形式读出来 使用fscanf函数
	//fscanf(pf, "%d-%f-%c",&(s2.age),&(s2.a),&(s2.b));
	/*printf("%d-%f-%c", s2.age, s2.a, s2.b);*/
	fclose(pf);
	pf = NULL;
	return 0;
}

在文件中成功生成了格式化的数据~

再来看看fscanf函数~

struct S{
	int age;
	float a;
	char b;
}s;
int main() {
	FILE* pf = fopen("data.txt","r");//r和w每次写的时候不小心写反会发生什么？
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	s.age = 10;
	s.a = 1.1f;
	s.b = 'c';
	struct S s2 = { 0 };
	/*fprintf(pf, "%d-%f-%c", s.age, s.a, s.b);*/
	对应的 把文件中的数据以格式化的形式读出来 使用fscanf函数
	fscanf(pf, "%d-%f-%c",&(s2.age),&(s2.a),&(s2.b));
	printf("%d-%f-%c", s2.age, s2.a, s2.b);
	fclose(pf);
	pf = NULL;
	return 0;
}

3.4 文件的二进制输入输出函数

fwrite 是二进制的输出函数，它只适用于文件流，不像以上那些函数，适用于所有输入/输出流。

//size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
//ptr是数据源， size是要写的数据大小，count是要写的数据个数      stream是目标文件流
int main() {
	FILE* pf = fopen("data.txt", "wb");//注意mode
		if (pf == NULL) {
		perror("fopen");
		return 1;
	}
		int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
		fwrite(arr,sizeof(arr[0]),sizeof(arr)/sizeof(arr[0]),pf);
		
		fclose(pf);
		pf = NULL;
	return 0;
}

结果会在data.txt文件中写入一段乱码，但是可以通过VS 编译器中的源文件->添加->现有项->以二进制形式打开文件来观察我们写入的数据~

我们观察到，data.txt文件确实放置了1-10（小端存储）

再来看看与fwrite函数相对应的二进制输入函数fread

//size_t fread(void* ptr, size_t size, size_t count, FILE* stream);
//ptr是你要读出的数据的位置
int main()
{
	FILE* pf  = fopen("data.txt","rb");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	int arr[20] = { 0 };
	fread(arr,4,11,pf);
	for (int i = 0; i < 11; i++)
	{
		printf("%d ", arr[i]);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

3.5 比较特殊的两个函数sscanf和sprintf

sprintf是将格式化的数据转化为（输出成为）字符串，而sscanf是将字符串中的数据以格式化的方式读取出来放进变量中~

//sprintf 把数据转化为字符串
//int sprintf ( char * str, const char * format, ... );
struct S{
	int age;
	float a;
	char b;
}s;
int main() {
	FILE* pf = fopen("data.txt","w");//r和w每次写的时候不小心写反会发生什么？
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	char arr[20] = { 0 };
	s.age = 10;
	s.a = 1.1f;
	s.b = 'c';
	struct S s2 = { 0 };
	sprintf(arr, "%d-%f-%c", s.age, s.a, s.b);//将格式化的数据转换成字符串 存到arr中去
	printf("%s\n", arr);
	//sscanf将字符串转化为格式化的数据
	//int sscanf ( const char * s, const char * format, ...);
	sscanf(arr, "%d-%f-%c", &s2.age, &s2.a, &s2.b);
	printf("%d-%f-%c", s2.age, s2.a, s2.b);
	fclose(pf);
	pf = NULL;
	return 0;
}

结果如上。

总结以下：

4.文件的随机读写

上文我们介绍的函数都是按照文件中数据正序进行读写，而如果我们要对文件进行随机（乱序）读写，那我们应该怎么办呢？其实也很简单，上文提到了读写文件时存在文件指针（光标），如果我们能再读写文件之前调整光标到我们想要的位置，那我们是不是就能够进行文件的随机读写呢？

4.1 fseek函数

通过函数声明可知，这个函数的可以操纵目标流的文件指针相对起始位置的偏移量来实现文件的随机读写

以下是该函数的一些细节：

由此可知，函数的第三个形参origin有三个取值，分别可以使光标位于文件起始位置，当前位置和末尾位置（最后面元素的下一个）

函数操纵光标如果成功，则返回0，否则返回一个非0的数

int main() {
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int ch = 0;
	for (int i = 0; i < 3; i++)
	{
		ch = fgetc(pf);
		printf("%c\n", ch);
	}
	//移动光标位置fgetc得到a的值 origin有三种方法
	/*fseek(pf, -3, SEEK_CUR);
	ch = fgetc(pf);
	printf("%c\n", ch);*/
	/*fseek(pf, 0, SEEK_SET);
	ch = fgetc(pf);
	printf("%c\n", ch);*/
	fseek(pf,-6,SEEK_END);
	ch = fgetc(pf);
	printf("%c\n", ch);
	fclose(pf);
	pf = NULL;
	return 0;
}

4.2 ftell函数和rewind函数

ftell函数用来获取文件指针相对于起始位置的偏移量，rewind函数用来重置文件指针，使其移到末尾位置

//long int ftell ( FILE * stream );
int main() {
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int ch = 0;
	for (int i = 0; i < 3; i++)
	{
		ch = fgetc(pf);//读完之后又往后走了一个位置，再读的话该读d了 
		//这条语句结束后偏移量为3
		printf("%c\n", ch);
	}
	int a = ftell(pf);
	printf("%d\n", a);
	rewind(pf);//重置光标
	ch = fgetc(pf);
	printf("%c\n", ch);
	fclose(pf);
	pf = NULL;
	return 0;
}

5.文件读取文件结束时的判定

读取文件会有两种状态，成功（文件读取完毕后返回文件末尾）和失败（读写文件中途出错退出），我们可以通过两个函数来判断文件状态。

这两个函数分别是feof和ferror,feof函数用来判断文件是否是读取到文件末尾结束，如果是则返回EOF，否则返回0，而ferror函数是如果文件中途读写出错，则返回一个非0值否则返回0，二者正好相反~

如果按照文件和函数再细分一下，则有：

示例

#include <stdlib.h>
int main(void)
{
	int c; // 注意：int，非char，要求处理EOF 
	FILE* fp = fopen("data.txt", "r");
	if (!fp) {
		perror("File opening failed");
		return EXIT_FAILURE;
	}
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF 
	while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环 
	{
		putchar(c);
	}
	//读取完毕
		//判断是什么原因结束的 
		if (ferror(fp))
			puts("I/O error when reading");
		else if (feof(fp))
			puts("End of file reached successfully");
	fclose(fp);
}

代码如下：

enum { SIZE = 5 };
int main(void)
{
	double a[SIZE] = { 1.,2.,3.,4.,5. };
	FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式 
	fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组 
	fclose(fp);
	double b[SIZE];
	fp = fopen("test.bin", "rb");
	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 handling 
		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;
}

6.文件缓冲区

这里直接引用大佬的博客~什么是缓冲区（buffer），什么是缓存（cache）_数据缓冲区-CSDN博客

困的睡不着.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
C语言版的文件操作看这一篇就足够了！详解~

而我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。需要注意的是，fclose函数将形参中传递的文件指针指向的文件流关闭后，不会将其地址置空，所以pf指针还会访问到他所保存的内存中的地址，这是不安全的，会形成。文件的打开用fopen函数完成，他这个函数有两个参数，第一个参数是指文件的名称，第二个是指打开文件的方式。
复制链接

扫一扫