【C语言】文件操作（详细！！）

等风来，随风扬

于 2024-08-22 23:16:32 发布

阅读量707

点赞数 23

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

本文链接：https://blog.csdn.net/2401_83871176/article/details/141439501

版权

1、为什么使用文件

使用文件的原因：使用文件主要是为了在程序的执行过程中保存、读取和交换数据。文件提供了一种持久化存储数据的方式，使得程序在关闭后，数据不会丢失，可以被其他程序或后续的程序执行周期重新读取和处理。

1.0 什么是文件

磁盘（硬盘）上的文件是文件。
但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（文件功能分类上看）
文件名包含3部分：文件路径+文件名主干+文件后缀

例如：c:\code\test.txt

文件路径：c:\code\
文件名主干：test
文件后缀：txt

2.0 文件的分类

2.0.0 程序文件

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

2.0.1 数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。
之前的章节中，我们主要关注的是通过终端（即键盘和显示器）来进行数据的输入和输出操作。除了通过终端进行即时的数据交换外，我们还经常需要处理磁盘上的文件（有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用）。

3、文本文件与二进制文件

二进制文件：数据在内存中以二进制的形式存储，如果不加转换的输出到外存的文件中，就是二进制文件。
文本文件：文本文件以ASCII码方式（也称文本方式）存储，英文、数字等字符存储的是ASCII码，而汉字等则存储为机内码¹。

`一个数据在文件中怎么存储？

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

例如：

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

代码：

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

二进制文件如果通过文本编辑器打开通常是读不懂的内容，所以，要正确查看或编辑二进制文件，需要使用专门的二进制编辑器或相应的文件查看工具。比如：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4、文件的打开和关闭

4.0 流和标准流

1.流

流（Stream）是外部设备（文件、光盘、软盘、屏幕等）和程序之间的桥梁，它负责数据的输入和输出。作为程序员，我们不需要关心流是如何具体将数据输入或输出到外部设备的，但我们需要了解如何建立流与程序之间的联系。

C程序针对文件、画面、键盘等的数据输入输出操作都是通过流操作的。

一般情况下，我们要想向流里写数据，或者从流中读取数据，都是要打开流，然后操作。

2.标准流

当我们从键盘输入数据或向屏幕输出数据时，并没有显式地打开流，这是因为C语言程序在启动时会自动打开三个标准流：标准输入流（stdin）、标准输出流（stdout）和标准错误流（stderr）。

stdin —— 程序从标准输入流读取数据。在命令行中，标准输入通常是键盘；在文件中，它可以是文件的开始部分。标准输入的文件描述符通常为0。scanf函数就是从标准输入流中读取数据。
stdout —— 程序向标准输出流写入数据。在命令行中，标准输出通常是显示器（屏幕）；在文件中，它可以是文件的内容。标准输出的文件描述符通常为1。printf函数就是将信息输出到标准输出流中。
stderr —— 标准错误流，大多数环境中输出到显示器界面。

stdin、stdout、stderr 三个流的类型是： FILE *,通常称为文件指针。

C语言中，就是通过 FILE* 的文件指针来维护流的各种操作的。

4.1 文件指针

在C语言中，文件指针是一个指针变量，它指向一个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.2 文件打开宇与关闭

前面的知识是铺垫。

文件的操作：1.打开文件 2.读写文件 3.关闭文件

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

//打开文件
FILE* fopen(const char* filename, const char* mode);

//关闭文件
int fclose(FILE* stream);

filename : 文件名
mode : 文件的打开方式

mode 如下：

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

例如“w”：

#include<stdio.h>

int main()
{
	//1. 打开文件
	//打开文件成功的话，返回的是有效的指针
	//如果打开失败，则返回NULL
	FILE* pf = fopen("data.txt", "w");

	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
    // 关闭...
}

如果当前目录不存在data.txt这个文件，如果以“w”打开：

当前目录存在test.txt文件，如果以“w”打开：

fopen fclose example :

#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "w");//以写的方式打开文件
	//. 表示当前路径
	//.. 表示上一级路径
	//FILE* pf = fopen("D:\\code\\CL\\Desktop\\test.txt", "w");//绝对路径
	//FILE* pf = fopen(".\\..\\test.txt", "w");//相对路径(当前路径的上一级路径)
		
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	else
	{
		printf("文件打开成功\n");
	}
	//写文件
	//...
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

5、文件的顺序读写和随机读写

5.1 顺序读写函数介绍

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

上面说的适用于所有输入流一般指适用于标准输入流和其他输入流（如文件输入流）；所有输出流一般指适用于标准输出流和其他输出流（如文件输出流）。

比如：

5.1.0 fputc 和 fgetc

fputc

int fputc ( int character, FILE * stream );

character 是要写入的字符，虽参数类型是 int，但函数仅使用其低八位（即 ASCII 码值）。
stream 是指向 FILE 对象的指针，该对象标识了要写入字符的文件流。
返回值：
- 如果写入成功，fputc 函数返回写入的字符的 ASCII 码值。
- 如果写入失败，则返回 EOF

例如：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// 写文件
	/*fputc('a', pf);
	fputc('b', pf);
	fputc('c', pf);
	fputc('d', pf);
	fputc('e', pf);
	fputc('f', pf);*/

	int i = 0;
	for (i = 'a'; i < 'z'; i++)
	{
		fputc(i, pf);
	}

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

运行结果：

fgetc

int fgetc ( FILE * stream );

fgetc函数从由stream指向的文件中读取下一个字符（一个字节）。
返回值：
- 读取成功时，返回读取到的字符的ASCII码值（以无符号字符形式读取，并转换为整型）。
- 如果到达文件末尾（EOF）或读取过程中发生错误，则返回EOF。

例如：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// 读文件
	int ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);
	
	// 关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

或者：

5.1.1 fputs 和 fgets

fputs

int fputs(const char *str, FILE *stream);

str 参数是一个指向以 null 结尾的字符串的指针，该字符串是要被写入文件的。
返回值：
- 成功返回一个非负值（通常是 0）；
- 如果发生错误，则返回 EOF。

例如：

#include<stdio.h>
int main()
{
	// 打开文件
	FILE* pf = fopen("data.txt","w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// 写文件
	fputs("I love three things in this world\n", pf);
	fputs("the sun the moon and you\n", pf);
	fputs("The sun for the day, the moon for the night and you forever\n", pf);

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

	return 0;
}

打开data.txt文件：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

fgets

char * fgets ( char * str, int num, FILE * stream );

从流中读取字符，并将它们存储到字符串 str 中，直到读取了 (num-1) 个字符，或者遇到换行符或文件结束符(EOF)。
返回值：
- 成功时，fgets 返回指向 str 的指针。
- 失败时：返回空指针。

注意：

fgets 与 gets函数不同，后者由于无法限制读取的字符数，容易导致缓冲区溢出等安全问题，因此在C 编程中推荐使用 fgets。

例如：

#include<stdio.h>
int main()
{
	// 打开文件
	FILE* pf = fopen("text.txt","r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// 读文件
	char arr[20] = "xxxxxxxxxxxxxx";
	fgets(arr,5, pf);
	printf("%s\n", arr);

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

	return 0;
}

fgets 允许程序员指定读取的最大字符数（num-1个字符加上末尾的空字符’\0’）。此外，fgets 会将换行符（如果有的话）也存储在字符串中，这意味着如果输入的字符串长度小于num-1，则字符串的末尾将包含一个换行符和一个空字符。

比如还是刚刚的代码，修改一下 fgets(arr,10,pf); 和 text.txt 文件内容。

结果如下：

在键盘上读取：

#include<stdio.h>
int main()
{
	char arr[20] = { 0 };
	fgets(arr, 20, stdin);
	fputs(arr, stdout);

	return 0;
}

5.2 对比一组函数

5.2.0 printf 和 fprintf

int printf ( const char * format, ... );
int fprintf ( FILE * stream, const char * format, ... );

format：格式字符串，用于指定后续参数如何格式化为输出文本
...：可变参数列表

例如：

#include<stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = { "xiaofeng", 22, 99.0f };
	//1. 打开文件
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2. 写文件
	fprintf(pf,"%s %d %.1f", s.name, s.age, s.score);// 写到文件中
	printf("%s %d %f", s.name, s.age, s.score);// 写到屏幕上

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

5.2.1 scanf 和 fscanf

int scanf ( const char * format, ... );
int fscanf ( FILE * stream, const char * format, ... );

例如：

#include<stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = {0};
	//1. 打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2. 读文件
	//scanf("%s %d %f", s.name, &(s.age), &(s.score));// 从键盘中读取
	//从文件中读取信息，存放到s的各个成员中
	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));// 从文件中读取

	//打印在屏幕上
	//printf("%s %d %.1f\n", s.name, s.age, s.score);
	fprintf(stdout, "%s %d %.1f\n", s.name, s.age, s.score);

	//3. 关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

5.2.2 sprintf 和 sscanf

1、sprintf

int sprintf(char *str, const char *format, ...);

sprintf其实是将格式化的数据写到字符串中，你可以理解为将格式化的数据转换成字符串。

2、sscanf

int sscanf ( const char * s, const char * format, ...);

sscanf 用于从字符串中读取格式化的输入。

总代码：

#include<stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};
	
int main()
{
	char arr[100] = { 0 };
	struct S s = { "xiaodeng", 22, 88.3f };
		
	//临时变量
	struct S tmp = { 0 };
	
	//将s中的各个数据转换成字符串，存放在arr中
	sprintf(arr, "%s %d %f", s.name, s.age, s.score);
	//printf("%s\n", arr);
	
	//从字符串arr中提取格式化的数据，存放在tmp中
	sscanf(arr, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
	printf("%s %d %f\n", tmp.name, tmp.age, tmp.score);
	
	return 0;
}

运行结果：

5.2.3 小结

scanf / printf：针对标准输入流/标准输出流的格式化输入/输出函数。

fscanf / fprintf：针对所有输入流/标准输出流的格式化输入/输出函数。

sscanf / sprintf：将格式化的数据转化成字符串，从字符串中提取格式化的数据。

5.3 fwrite 和 fread

1、fwrite

将数据块写入流。

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

将ptr中count 个，大小为size 个字节的数据写到文件中。

ptr：指向要写入的数据块的指针。
size_t size: 指定了每个数据项的大小（以字节为单位）
size_t count: 指定了要写入的数据项的数量。
FILE* stream: 这是一个指向 FILE 对象的指针，该对象表示了要写入的文件。

例如：

#include<stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct S s = { "xiaolai", 26, 98.8f };
	//以二进制的形式写到文件中

	//1. 打开文件
	FILE* pf = fopen("text.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.写文件
	fwrite(&s, sizeof(struct S), 1, pf);

	//3.关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

以文本形式打开是乱码的，到时候我们可以通过fread读出来：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2、fread

从流中读取数据块。

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

从文件中读取count 个大小为size 个字节的数据,存放在ptr 指向的空间中。

例如：

#include<stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct S s = { 0 };
	//读取二进制的信息写到文件中

	//1. 打开文件
	FILE* pf = fopen("text.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.读文件
	fread(&s, sizeof(struct S), 1, pf);
	printf("%s %d %f\n", s.name, s.age, s.score);

	//3.关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

结果：

5.4 文件的随机读写

5.4.0 fseek

根据文件指针的位置和偏移量来定位文件指针（文件内容的光标）。

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

origin: 起始位置
offset：从 origin 指定的位置开始的偏移量，以字节为单位。这个值可以是正数或负数。
origin取值：
- SEEK_SET：文件的开头（0位置）。
- SEEK_CUR：当前位置。
- SEEK_END：文件的末尾。

示例：

#include<stdio.h>
int main()
{
	//1. 打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.读文件
	int ch = 0;
	ch = fgetc(pf);//a
	printf("%c\n", ch);
	ch = fgetc(pf);//b
	printf("%c\n", ch);

	//定位文件指针
	//fseek(pf, 4, SEEK_SET); // 文件指针，在文件开始
	fseek(pf, 2, SEEK_CUR);   // 文件指针，在文件当前位置
	//fseek(pf, -2, SEEK_END);// 文件指针，在文件末尾
	ch = fgetc(pf);
	printf("%c\n", ch);//e
 
	//3.关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

5.4.1 ftell

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

long int ftell ( FILE * stream );

#include<stdio.h>
int main()
{
	//1. 打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.读文件
	int ch = 0;
	ch = fgetc(pf);//a
	printf("%c\n", ch);
	ch = fgetc(pf);//b
	printf("%c\n", ch);

	//定位文件指针
	fseek(pf, -2, SEEK_END);// 文件指针，在文件末尾
	ch = fgetc(pf);
	printf("%c\n", ch);//e

	//输出文件指针相较于文件的起始位置的偏移量
	printf("%d\n", ftell(pf));

	//3.关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

5.4.2 rewind

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

void rewind ( FILE * stream );

#include<stdio.h>
int main()
{
	//1. 打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.读文件
	int ch = 0;
	ch = fgetc(pf);//a
	printf("%c\n", ch);
	ch = fgetc(pf);//b
	printf("%c\n", ch);
	
	//将文件指针重新定位到文件的起始位置
	rewind(pf);
	ch = fgetc(pf);
	printf("%c\n", ch);//a
 
	//3.关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

6、文件读取结束的判定

6.0 feof

EOF 是文件结束的标志，但是feof 不是用来判断文件是否结束的！！！

牢记：在文件读取过程中，不能能feof函数的返回值直接来判断文件的是否结束。

feof 的作用是：当文件读取结束的时候，判断是读取结束的原因是否是：遇到文件尾结束。

在文件读取过程中，有可能读取文件结束的原因：

遇到文件末尾
遇到错误

1、文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）

例如：

fgetc 判断是否为 EOF .
fgets 判断返回值是否为 NULL .

2、二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。

例如：

fread判断返回值是否小于实际要读的个数。

例如：

#include<stdio.h>
int main()
{
	//1. 以读的形式打开文件
	FILE* pf = fopen("text1.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.读文件
	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)//a
	{
		printf("%c ", ch);
	}
	//int ret = feof(pf);
	//printf("%d\n", ret);// 没有遇到文件末尾返回 0

	//判断是什么原因结束的
	if (ferror(pf))
		puts("I/O error when reading\n");
	else if (feof(pf))
		puts("End of file reached successfully\n");

	//3.关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

6.1 拷贝文件

//拷贝文件
//text1.txt    --->  text2.txt
#include<stdio.h>
int main()
{
	//打开文件
	FILE* pfread = fopen("text1.txt", "r");
	if (pfread == NULL)
	{
		perror("fopen\n");
		return 1;
	}

	FILE* pfwrite = fopen("text2.txt", "w");
	if (pfwrite == NULL)
	{
		perror("fopen\n");
		fclose(pfread);
		return 1;
	}
	//读/写文件
	int ch = 0;
	while ((ch = fgetc(pfread)) != EOF)
	{
		fputc(ch, pfwrite);
	}

	//关闭文件
	fclose(pfread);
	pfread = NULL;

	fclose(pfwrite);
	pfwrite = NULL;

	return 0;
}

6.2 文件结束判断例子

文本文件

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
	int c; // 注意：int，非char，要求处理EOF
	FILE* fp = fopen("test.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);
}

二进制文件

#include <stdio.h>
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);
}

7、文件缓冲区

文件缓冲区是存储在内存区中的一块空间，用于暂时存放读写期间的文件数据。它通过磁盘缓存来实现，磁盘缓存本身并不是一种实际存在的存储介质，而是依托于固定磁盘，利用主存中的存储空间来暂存从磁盘中读出或写入的信息。缓冲区的大小根据C编译系统决定。

工作原理：

当应用程序需要读取文件时，操作系统会将文件的一部分数据从磁盘读取到文件缓冲区中。然后，从缓冲区逐个地将数据送到程序数据区（程序变量等）。
同样地，当应用程序需要写入文件时，数据会首先被写入到文件缓冲区中。当缓冲区满或满足其他条件时（如关闭文件时），缓冲区中的数据会被一次性写入磁盘。

测试代码：

#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
	FILE* pf = fopen("text.txt", "w");
	fputs("let your music,like a sword,pierce the noise of the market to its heart ", pf);//先将代码放在输出缓冲区
	printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
	Sleep(10000); // 10 秒
	printf("刷新缓冲区\n");
	fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
	//注：fflush 在⾼版本的VS上不能使⽤了
	printf("再睡眠10秒-此时，再次打开text.txt⽂件，文件有内容了\n");
	Sleep(10000);
	fclose(pf);
	//注：fclose在关闭文件的时候，也会刷新缓冲区
	pf = NULL;
	return 0;
}

结论：

在C语言处理文件时，由于引入了缓冲机制，对文件的读写操作并不总是立即反映到物理存储介质上，而是先暂存在内存中的缓冲区。因此，为了确保所有的数据都被正确地写入文件或所有的输入都被完全读取，开发者需要在适当的时候手动刷新缓冲区，或者在完成文件操作后关闭文件。如果不做，可能导致读写文件出问题。

点赞☀收藏 ⭐ 关注！

在这里插入图片描述

Respect！！!

计算机内部存储，处理加工和传输汉字时所用的由0和1符号组成的代码 ↩︎

等风来，随风扬

关注

23
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
【C语言】文件操作（详细！！）

磁盘（硬盘）上的文件是文件。但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（文件功能分类上看）文件名包含3部分：文件路径+文件名主干+文件后缀文件路径：c:\code\文件名主干：test文件后缀：txt函数名功能适用于fgetc字符输入函数所有输入流fputc字符输出函数所有输出流fgets文本行输入函数所有输入流fputs文本行输出函数所有输出流fscanf格式化输入函数所有输入流fprintf格式化输出函数所有输出流fread。
复制链接

扫一扫