目录
一、什么是文件
首先我们要明白，为什么我们要使用文件？
如果没有文件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运行程序，是看不到上次程序的数据的，如果要将数据运行持久化的保存，我们可以使用文件。
程序文件和数据文件
程序文件
程序文件包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows 环境后缀为.exe）
数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。
本博客主要讲述的是数据文件的读写操作。
在没有文件操作的C语言终端程序中，数据的输入和输出都是以终端为对象的，即从终端的键盘输入数据，运行结果在屏幕上显示。
其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
文件名
一个文件要有一个 唯一的文件标识，以便用户识别和引用文件名包含3部分：文件路径+文件名主干+文件后缀例如： c:\code\test.txt为了方便起见，文件标识常被称为 文件名
二进制文件和文本文件
根据数据的组织形式，数据文件被称为 文本文件（肉眼看得懂的）或者 二进制文件。数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是 二进制文件。如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是 文本文件。⼀个数据在内存中是怎么存储的呢？字符⼀律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符⼀个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2019测试）。
int main()
{
int a = 10000;
//打开一个文件，想以二进制的形式往里面写数据
//以写的形式去打开文件，如果文件不存在，则会自动创建
FILE* pf = fopen("text.txt", "wb");
//二进制的形式写到文件中
//a占4字节，把1个整形a的数据写进pf指向的文件中
fwrite(&a, 4, 1, pf);
fclose(pf);
pf = NULL;
return 0;
}在VS上打开二进制文件：
二、文件的打开和关闭
流和标准流
我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输入输出操作各不相同，为了方便程序员对各种设备进行方便的操作，我们抽象出了流的概念，我们可以把流想象成流淌着字符的河。C程序针对文件、画面、键盘等的数据输入输出操作都是通过流操作的。一般情况下，我们要想向流里写数据，或者从流中读取数据，都是要打开流，然后操作。
那为什么我们从键盘输入数据，向屏幕上输出数据，并没有打开流呢？那是因为C语言程序在启动的时候，默认打开了3个流：
- stdin - 标准输入流，在大多数的环境中从键盘输入，scanf函数就是从标准输入流中读取数据。（键盘 ---> 标准输入设备）
- stdout - 标准输出流，大多数的环境中输出至显显示器界面，printf函数就是将信息输出到标准输出流中。（屏幕 ---> 标准输出设备）
- stderr - 标准错误流，大多数环境中输出到显示器界面
这是默认打开了这三个流，我们使用scanf、printf等函数就可以直接进行输入输出操作的。stdin、stdout、stderr 三个流的类型是： FILE* ，通常称为 文件指针。C语言中，就是通过 FILE* 的文件指针来维护流的各种操作的。
文件指针
不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。每当打开⼀个文件的时候，系统会根据文件的情况自动创建⼀个FILE结构的变量，并填充其中的信息，使用者不必关心细节。⼀般都是通过⼀个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。下面我们可以创建⼀个FILE*的指针变量:
FILE* pf;//文件指针变量
文件操作——打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。在编写程序的时候，在打开文件的同时，都会返回⼀个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。（打开失败返回空指针）ANSIC 规定使用 fopen 函数来打开文件， fclose 来关闭文件。
fopen（打开文件函数）
使用fopen要包含头文件 <stdio.h>FILE * fopen ( const char * filename, const char * mode );filename：文件名mode：打开方式
- 绝对路径（Absolute Path）：从根目录（/）开始的完整路径，不依赖当前工作目录。例如，
/home/user/documents是documents文件夹的绝对路径。- 相对路径（Relative Path）：不以根目录开始的路径，相对于当前工作目录。例如，如果当前工作目录是
/home/user，要访问同一目录下的documents文件夹，只需输入./documents（.代表当前目录）或者直接输入documents。
此时text.txt是文件的相对路径：FILE* pf = fopen("text.txt", "w");
绝对路径
我们可以看到text.text是在 D:\code\比特C语言112期\test_c_code\2024_4_4\2024_4_4的文件夹中，所以我们用绝对路径打开text.txt是以这种形式：FILE* pf = fopen("D:\\code\\比特C语言112期\\test_c_code\\2024_4_4\\2024_4_4\\text.txt", "w");注意：之所以我们用 \\ 是为了防止 \ 和后面的字符搭配变成转义字符
| 文件使用方式 | 含义 | 如果指定文件不存在 |
|---|---|---|
| "r"(只读) | 为了输入数据，打开一个已经存在的文本文件 | 出错 |
| "w"(只写) | 为了输出数据，打开一个文本文件 | 建立一个新的文件 |
| "a"(追加) | 向文本文件尾添加数据 | 建立一个新的文件 |
| "rb"(只读) | 为了输入数据，打开一个二进制文件 | 出错 |
| “wb"(只写) | 为了输出数据，打开一个二进制文件 | 建立一个新的文件 |
| "ab"(追加) | 向一个二进制文件尾添加数据 | 建立一个新的文件 |
| “r+”(读写) | 为了读和写，打开一个文本文件 | 出错 |
| “w+”(读写) | 为了读和写，建一个新的文件 | 建立一个新的文件 |
| "a+”(读写) | 打开一个文件，在文件尾进行读写 | 建立一个新的文件 |
| “rb+”(读写) | 为了读和写打开一个二进制文件 | 出错 |
| "wb+”(读写) | 为了读和写，新建一个新的二进制文件 | 建立一个新的文件 |
| “ab+”(读写) | 打开一个二进制文件，在文件尾进行读和写 | 建立一个新的文件 |
注：当使用“w”，“wb”，“w+”，“wb+”打开文件时会清除文件原本存储的数据。
int main()
{
//打开文件
FILE* pFile = fopen("text.txt", "w");
//判断指针是否为空指针
if (pFile == NULL)
{
perror("fopen");
return 1;
}
return 0;
}fclose（关闭文件函数）
使用fclose要包含头文件 <stdio.h>int fclose ( FILE * stream );stream：传入要关闭的文件的文件指针。
int main()
{
//打开文件
FILE* pFile = fopen("text.txt", "w");
//判断指针是否为空指针
if (pFile == NULL)
{
perror("foen");
return 1;
}
//文件操作
//将字符串fopen example写入pFile指向的文件中
fputs("fopen example", pFile);
//关闭文件
fclose(pFile);
pFile = NULL;
return 0;
在关闭文件成功之后我们应该将原本的文件指针置为空（NULL），避免野指针的产生。
输入操作(读)/输出操作(写)
三、文件的顺序读写
| 函数名 | 功能 | 适用于 |
| fgetc | 字符输入函数 | 所有输入流 |
| fputc | 字符输出函数 | 所有输出流 |
| fgets | 文本行输入函数 | 所有输入流 |
| fputs | 文本行输出函数 | 所有输出流 |
| fscanf | 格式化输入函数 | 所有输入流 |
| fprintf | 格式化输出函数 | 所有输出流 |
| fread | 二进制输入 | 文件 |
| fwrite | 二进制输出 | 文件 |
上面说的适用于所有输入流一般指适用于标准输入流和其他输入流（如文件输入流）；所有输出流一般指适用于标准输出流和其他输出流（如文件输出流)所有输入流：包含stdin（键盘就是标准输入设备），文件输入流所有输出流：包含stdout（屏幕就是标准输出设备），文件输出流
fgetc 字符输入函数
使用fgetc库函数需要包含头文件 <stdio.h>
功能：从所有输入流（stdin或者文件输入流）中读取一个字符
int fgetc( FILE *stream );
stream:接收指向所要读取文件的指针
该函数成功读入数据时会返回读取字符的ASCII值
int main()
{
FILE* pfRead = fopen("text.txt", "r");
if (pfRead == NULL)
{
perror("fopen");
return 1;
}
//读文件
printf("%c", getc(pfRead));//一次读取1个字符
printf("%c", getc(pfRead));
printf("%c", getc(pfRead));
//关闭文件
fclose(pfRead);
pfRead = NULL;
return 0;
}运行结果
fputc 字符输出函数
使用fputc库函数需要包含头文件 <stdio.h>
功能：将字符写入所有输出流中（stdout或者文件输出流）
int fputc( int c, FILE *stream );
character:接收所要存入的字符的ASCII值
stream:接收指向所要存入文件的指针
当该函数成功运行时返回所存入字符的ASCII码值
int main()
{
//因为我们是用w的形式来打开文件，所以会把原有文件内的数据清空
FILE* pfWrite = fopen("text.txt", "w");
if (pfWrite == NULL)
{
perror("foen");
return 1;
}
//写文件
fputc('g', pfWrite);
fputc('o', pfWrite);
fputc('o', pfWrite);
fputc('d', pfWrite);
//关闭文件
fclose(pfWrite);
pfWrite = NULL;
return 0;
}运行结果：
fgets 文本行输入函数
使用fgets库函数需要包含头文件 <stdio.h>
功能：从所有输入流（stdin或者文件输入流）中读取一行字符串
char *fgets( char *string, int n, FILE *stream );
str:是指向一个字符数组的指针，该数组存储了要读取的字符串。
num:接收要复制到 string 中的最大字符数（包括终止空字符）
stream:接收指向所要读取文件的指针
此时我将text.txt中的内容改成
int main()
{
FILE* pf = fopen("text.txt", "r");
char buf[1024] = { 0 };
if (pf == NULL)
{
perror("fopen");
return 1;
}
//从pf指向的文件中读取一行数据放到buf中，最多读取1024个字符
fgets(buf, 1024, pf);
printf("%s", buf);//这里输出的是hello+回车
fgets(buf, 1024, pf);
printf("%s", buf);//这个输出的是bit
fclose(pf);
pf = NULL;
return 0;
}运行结果：
注意！！！
每次使用fgets从文件中获取一行数据放在数组中，存放位置都是从数组0下标的位置开始，所以第二次输出buf数组的内容输出的是bit，而不是hello\nbit
fputs 文本行输出函数
使用fputs库函数需要包含头文件 <stdio.h>
功能：将一行字符串写入所有输出流中（stdout或者文件输出流）
int fputs( const char *string, FILE *stream );
str:接收指向将要存入字符串的指针，包含了要写入的以空字符终止的字符序列。
stream:接收指向所要存入文件的指针
int main()
{
FILE* pf = fopen("text.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
fputs("tiantian", pf);
fputs("kaixin", pf);
fclose(pf);
pf = NULL;
return 0;
}运行结果：
我们如果想要tiantian和kaixin之间有分隔，我们就可以在存入字符串时在后面加上换行符'\n' 来分隔：
由于前面我们说过fputs和fgets还适用于stdout和stdin，所以我们想要从键盘读取一行文本输出到屏幕上，这要怎么做？
扩展：puts 输出字符串的函数
使用puts需要包含头文件 <stdio.h>
功能：向标准输出设备屏幕输出字符串并换行
int puts( const char *string );
该函数从指定的地址 （str） 开始复制，直到到达终止 null 字符 （'\0'）。此终止 null 字符不会复制到流中。
请注意，puts 与 fputs 的不同之处不仅在于它使用 stdout 作为目标，而且还会自动在末尾附加一个换行符（fputs 不会）。
此时我把text.txt中的内容修改成
int main()
{
char buf[1024] = { 0 };
FILE* pf = fopen("text.txt", "r");
fgets(buf, 1024, pf);
puts(buf);
fgets(buf, 1024, pf);
puts(buf);
return 0;
}运行效果：
fprintf 格式化输出函数
使用fprintf 库函数需要包含头文件 <stdio.h>
功能：可以把不同类型的数据以格式化的形式输出到所有输出流中（stdout或者文件输出流）
printf：只能输出到stdout中
struct S
{
int n;
float score;
char arr[10];
};
int main()
{
struct S s = { 20,3.14f,"张大炮" };
FILE* pf = fopen("text.txt", "w");
if (pf == NULL)
{
perror("fopne");
return 1;
}
//以格式化的形式写文件
//把s里面的相关信息以格式化的形式写入到pf指向的文件里面去
fprintf(pf, "%d %f %s", s.n, s.score, s.arr);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行结果：
fscanf 格式化输入函数
使用fscanf 库函数需要包含头文件 <stdio.h>
功能：从所有输入流（stdin或者文件输入流）中读取格式化的数据并且存储到其他参数所指向的位置。
struct S
{
int n;
float score;
char arr[10];
};
int main()
{
struct S s = { 0 };
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopne");
return 1;
}
//格式化的输入数据--读取文件
//s.arr不需要取地址是因为数组名表示数组首元素的地址
//下面代码的意思
//从pf指向的文件中读取格式化的数据，存放到结构体变量s中
fscanf(pf, "%d %f %s", &(s.n), &(s.score), s.arr);
//打印s里面的数据
printf("%d %f %s\n", s.n, s.score, s.arr);
fclose(pf);
pf = NULL;
return 0;
}运行结果：
当然因为我们前面有说过fprintf和fscanf适用于所有流，所以我们可以从键盘读取格式化的数据，并且以格式化的形式打印到屏幕上
struct S
{
int n;
float score;
char arr[10];
};
int main()
{
struct S s = { 0 };
//从键盘格式化的读取数据
//s.arr之所以不用取地址是因为数组名表示首元素的地址
fscanf(stdin, "%d %f %s", &(s.n), &(s.score), s.arr);
//把格式化的数据输入到屏幕中
fprintf(stdout, "%d %f %s\n", s.n, s.score, s.arr);
return 0;
}运行结果：
扩展：对比一组函数
我们不难发现，除了sscanf 和 sprintf，其他的函数，我们都有介绍，所以接下来就和大家一起了解一下这两个函数，最后在做一个总结
sprintf
使用此函数需要包含头文件 <stdio.h>
功能：把格式化的数据转换成字符串
buffer：char型指针，指向欲写入的字符串地址。
这就是把后面格式化的数据转换成字符串类型输入到char*类型的buffer参数中。
struct S
{
int n;
float score;
char arr[10];
};
int main()
{
char buf[1024] = { 0 };
struct S s = { 20,3.14f,"abcdef" };
//把s里面的数据转换成字符串并存入到字符数组buf中
sprintf(buf, "%d %f %s", s.n, s.score, s.arr);
printf("%s\n", buf);
return 0;
}运行结果：
sscanf
使用此函数需要包含头文件 <stdio.h>
功能：从字符串中读取一个格式化的数据
这里就是把buffer里面的信息按照格式化的形式存放到后面的变量中
struct S
{
int n;
float score;
char arr[10];
};
int main()
{
struct S s = { 20,3.14f,"abcdef" };
struct S tmp = { 0 };
char buf[1024] = { 0 };
//把格式化的数据转换成字符串存储到buf中
sprintf(buf, "%d %f %s", s.n, s.score, s.arr);
//从buf中读取格式化的数据到tmp中
sscanf(buf, "%d %f %s\n", &(tmp.n), &(tmp.score), tmp.arr);
printf("%d %f %s\n", tmp.n, tmp.score, tmp.arr);
return 0;
}运行结果：
总结：
fwrite 二进制输出函数
使用此函数需要包含头文件 <stdio.h>
功能：以二进制的形式向文件写入数据，fwrite函数只适用于文件
size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );
buffer:接收要写入数据的指针或地址
size:接收要写入的每个数据的大小（以字节为单位）。
count:所要写入数据的个数（一次要写入几个元素）
stream:接收指向所要写入文件的指针
struct S
{
char name[20];
int age;
double score;
};
int main()
{
struct S s = { "张三",20,55.6 };
// wb是以二进制的形式写文件
FILE* pf = fopen("text.txt", "wb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//第一个参数接收的是要写入到文件数据的地址
//第二个参数要传入写入数据的大小
//第三个参数是要写入数据的个数
//第四个参数要传入要写入文件的地址
//下面代码的意思
//首先结构体变量s占32个字节，不懂的去看我写过的内存对齐
//然后我们一次把1个大小为32字节的结构体变量s的数据以二进制的形式写入到pf指向的文件中
fwrite(&s, sizeof(s), 1, pf);
fclose(pf);
pf = NULL;
return 0;
}我们如果直接打开text.txt来查看，我们肯定是会看不懂的
因此我们就可以用下面要介绍的 fread库函数来查看
fread 二进制输入函数
使用此函数需要包含头文件 <stdio.h>
功能：把二进制文件中的内容用二进制的形式读取出来，fread函数只适用于文件
size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );
buffer: 传入指向将要存储数据的变量的指针或地址
size: 传入每次从文件读取数据的大小（以字节为单位）
count: 传入要读取的对象个数
stream: 接收指向所要读取文件的指针
从流(stream)里面读count个数据，count个大小为size的数据，读出来放到buffer指向的空间去
我们不能发现，其实 fwrite 和 fread 的参数是一样的，理论上来说我们怎么写进去，我们就怎么读出来，只要我们修改函数名和存储变量的地址就可以了
struct S
{
char name[20];
int age;
double score;
};
int main()
{
struct S tmp = { 0 };
// rb是以二进制的形式来读取数据
FILE* pf = fopen("text.txt", "rb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//二进制的形式来读取数据
//从pf指向的文件中1次读取1个struc s大小的数据放到tmp中
//第一个参数：要存储数据的地址
//第二个参数，要读取文件数据的大小
//第三个参数：一次要向文件中读取多少个数据
//第四个参数：要以二进制的形式读取文件的指针
//下面代码的意思
//从pf指向的文件中，以二进制的形式一次读取1个大小为32的数据元素，然后把数据存放到结构体变量tmp中
fread(&tmp, sizeof(struct S), 1, pf);
//打印tmp内的数据，判断是否读取成功
printf("%s %d %lf\n", tmp.name, tmp.age, tmp.score);
fclose(pf);
pf = NULL;
return 0;
}运行结果：
四、文件的随机读写
修改text.txt中的内容
如果我们此时想打开文件时就可以直接访问字符d，那我们用上面的函数是无法做到的，所以这时就要用到随机读写（从文件某一位置开始读）这个位置由自己来指定
文件指针的偏移量
想要使用随机读写，那么就无法绕过偏移量这个概念，所以接下来就由我来跟大家来讲解
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//一次读取1个字符
int ch = fgetc(pf);
printf("%c ", ch);
ch = fgetc(pf);
printf("%c ", ch);
ch = fgetc(pf);
printf("%c ", ch);
fclose(pf);
pf = NULL;
return 0;
}运行结果：
我们可以发现fgetc函数每读取一次数据时下一次再重新读取时不会从文件开始的位置去读，而是从上一次读取结束的地方再次读取，这实际是FILE*类型的指针的偏移：
fseek 移动文件指针到指定位置
使用此函数需要包含头文件 <stdio.h>
功能：移动文件指针到指定的位置
用法1：
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
fseek(pf, 2, SEEK_SET);
int ch = fgetc(pf);
printf("%c\n", ch);
fclose(pf);
pf = NULL;
return 0;
}运行结果：
用法2：
注意：
- 文件指针指向了文件的末尾位置，并不是指向了字符f，而是指向了字符f的后1位
- 文件指针指向了文件的末尾位置，要是想要向前偏移，则偏移量处需要填写负数
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
fseek(pf, -3, SEEK_END);
int ch = fgetc(pf);
printf("%c\n", ch);
fclose(pf);
pf = NULL;
return 0;
}运行结果：
ftell 返回文件指针相对于起始位置的偏移量
使用此函数需要包含头文件 <stdio.h>功能：返回文件指针相对于起始位置的偏移量
long int ftell ( FILE * stream );
stream：传入所需计算偏移量的文件指针
函数的返回类型是 long int
例子1：
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
fseek(pf, -2, SEEK_END);
long int ret = 0;
ret = ftell(pf);
printf("%ld\n", ret);
fclose(pf);
pf = NULL;
return 0;
}
如果文件指针指向的是文件的起始位置，那么起始位置相对于起始位置的偏移量就是0
rewind 让文件指针的位置回到文件的起始位置
使用此函数需要包含头文件 <stdio.h>
功能：让文件指针的位置回到文件的起始位置
void rewind ( FILE * stream );stream:传入将要改变到起始位置的文件指针
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读取第一个字符，指针向后偏移1位
int ch = fgetc(pf);
printf("%c\n", ch);
//再次读取字符，文件指针继续向后偏移
ch = fgetc(pf);
ch = fgetc(pf);
//让文件指针回到文件的起始位置
rewind(pf);
ch = fgetc(pf);
printf("%c\n", ch);
return 0;
}运行结果：
五、文件读取结束的判断
被错误使用的 feof
首先：使用 feof时需要包含头文件 <stdio.h>
牢记：在文件读取过程中，不能用feof函数的返回值直接来判断文件的是否结束。
feof 的作用是：当文件读取结束的时候，判断读取结束的原因是否是：正常遇到文件尾结束
1.文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
EOF值是-1
例如：
- fgetc 判断是否为 EOF
- fgets 判断返回值是否为 NULL
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
feof：是检测流上的文件结束符的函数，如果文件结束，则返回非0值，否则返回0；站在光标所在位置，向后看还有没有字符,如果有，返回0；如果没有，返回非0。它并不会读取相关信息，只是查看光标后是否还有内容。ferror：在文件读取结束后，判断是否是因为遇到错误而结束。（返回非零表示出错，返回零表示没错）
#include <stdio.h>
#include <stdlib.h>
int main()
{
int ch = 0; //注意：int，非char，要求处理EOF
FILE* pf = fopen("text.txt", "r");
//如果pf为NULL就进到if语句中
if (!pf)
{
perror("fopen");
//用EXIT_FAILURE需要包含头文件<stdlib.h>
//EXIT_FAILURE表示的值是1
return EXIT_FAILURE;
}
//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
while ((ch = fgetc(pf))!= EOF)
{
putchar(ch);
}
printf("\n");
//判断什么原因结束的
if (ferror(pf))
{
puts("I/O error when readoing");
}
else if (feof(pf))
{
puts("End of file reached successfully");
}
fclose(pf);
pf = NULL;
return 0;
}运行结果：
不知道有没有人想过这边可不可以换成else
说要换成else的人一定是这么想的，因为文件已经读取结束了，如果没有走进ferror中，那肯定是有顺利读取完成，所以还不如把feof(pf)换成else，这不更简单？
事实上这段代码确实是可以怎么写的，因为我们前面有写 while ((ch = fgetc(pf))!= EOF)，这段代码就是一直从文件中读取数据，直到遇到了文件尾或者读取错误。但是如果有其它的情况我不敢保证是可以把feof(pf)换成else。这里来举个例子说明
如果我们读取文件读到1半时我们自己主动退了读取过程，那么ferror还是会返回0的（读取过程时不是遇到错误而结束），那么feof(pf)则因为文件指针并没有指向到文件尾，所以会返回0（文件指针后还有内容），因此如果用上面代码来写，则什么都不会输出。然而如果把feof(pf)换成else则会输出 End of file reached successfully
二进制文件的例子：
首先读下列代码前我们要了解 fread函数的返回值表示实际成功读取到数据的个数，而不是字节数。
enum
{
SIZE = 5
};
int main()
{
double a[SIZE] = { 1.0,2.0,3.0,4.0,5.0 };
FILE* pf = fopen("text.txt", "wb");//以二进制的形式写
fwrite(a, sizeof(double), SIZE, pf);
fclose(pf);
double b[SIZE] = { 0 };
pf = fopen("text.txt", "rb");
size_t ret = fread(b, sizeof(double), SIZE, pf);
if (ret == SIZE)
{
puts("Array read successfully，contents：");
for (int i = 0; i < SIZE; i++)
{
printf("%lf ", b[i]);
printf("\n");
}
}
else if (ferror(pf))
{
perror("Error reading text.txt");
}
else if (feof(pf))
{
printf("Error reading text.txt：unexpected end of file\n");
}
fclose(pf);
pf = NULL;
return 0;
}运行结果：
六、文件缓存区
ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每⼀个正在使用的文件开辟⼀块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才⼀起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。如果不想把输出缓冲区装满才写入到硬盘上去，我们可以刷新缓冲区。输入缓冲区同理
#include <stdio.h>
#include <windows.h>
//VS2019 WIN10环境测试
int main()
{
FILE* pf = fopen("text.txt", "w");
fputs("abcdef", pf);//先将代码放在输出缓冲区
printf("睡眠10秒-已经写数据了，打开text.txt文件，发现文件没有内容\n");
Sleep(10000);
printf("刷新缓存区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件(磁盘)
//注：fflush 在高版本的VS上不能使用了
printf("再睡眠10秒-此时，再次打开text.txt文件，文件有内容了\n");
Sleep(10000);
fclose(pf);
//注：fclose在关闭文件的时候，也会刷新缓冲区
pf = NULL;
return 0;
}运行效果：
是因为fclose关闭文件时也会刷新缓冲区，为了避免是fclose刷新缓冲区，所以我们先自己调用fflush来刷新缓冲区，把缓冲区中的数据放到文件里去，所以睡眠10秒使得fclose不会直接执行
7238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
