目录
- 1. 为什么使用文件？
- 2. 什么是文件？
- 3. 二进制文件和文本文件？
- 4. 文件的打开和关闭
- 4.2 文件指针
- 4.3 文件的打开和关闭
- 5. 文件的顺序读写
- 6. 文件的随机读写
- 7. 文件读取结束的判定
- 8. ⽂件缓冲区
1. 为什么使用文件？
如果没有文件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运行程序，是看不到上次程序的数据的，如果要将数据进行持久化的保存，我们可以使用文件。
2. 什么是文件？
磁盘（硬盘）上的文件是文件。
但是在程序设计中，我们⼀般谈的⽂件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
2.1 程序文件
程序文件包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
2.2 数据文件
文件的内容不⼀定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。
这一篇讨论的是数据文件。
在以前写的文章中所处理到的数据的输⼊输出都是以终端为对象的，即从终端的键盘输⼊数据，运⾏结果显示到显示器上。
其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
2.3 文件名
⼀个文件要有一个唯一的文件标识，以便用户识别和引⽤。
文件名包含3部分：文件路径+文件名主干+文件后缀
例如： c:\code\test.txt
为了方便起见，文件标识常被称为文件名。
文件名可以不包含后缀名。
文件名中不能包含这些字符：/ : * ? " < > |
3. 二进制文件和文本文件？
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
数据在内存中以二进制的形式存储，如果不加转换的输出到外存的文件中，就是⼆进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
⼀个数据在文件中是怎么存储的呢？
字符⼀律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占⽤5个字节（每个字符⼀个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2019测试）。
#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;
}
在VS上打开二进制文件
4. 文件的打开和关闭
4.1 流和标准流
4.1.1 流
我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输⼊输出操作各不相同，为了方便程序员对各种设备进行方便的操作，我们抽象出了流的概念，我们可以把流想象成流淌着字符的河。
C程序针对文件、画面、键盘等的数据输入输出操作都是通过流操作的。
⼀般情况下，我们要想向流里写数据，或者从流中读取数据，都是要打开流，然后操作。
4.1.2 标准流
那为什么我们从键盘输⼊数据，向屏幕上输出数据，并没有打开流呢？
那是因为C语言程序在启动的时候，默认打开了3个流：
• stdin - 标准输入流，在大多数的环境中从键盘输⼊，scanf函数就是从标准输入流中读取数据。（标准输入流相当于键盘）
• stdout - 标准输出流，大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。（标准输出流相当于显示器）
• stderr - 标准错误流，大多数环境中输出到显示器界面。（标准错误流也相当于显示器）
这是默认打开了这三个流，我们使用scanf、printf等函数就可以直接进行输入输出操作的。
stdin、stdout、stderr 三个流的类型是： FILE * ，通常称为文件指针。
C语言中，就是通过 FILE * 的文件指针来维护流的各种操作的。
4.2 文件指针
缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了⼀个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名 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*的指针变量:
1 FILE* pf;//⽂件指针变量
定义pf是⼀个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是⼀个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够间接找到与它关联的文件。
比如：
4.3 文件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回⼀个FILE*的指针变量指向该文件，也相当于建⽴了指针和文件的关系。打开失败则返回空指针
ANSI C 规定使用 fopen 函数来打开文件， fclose 来关闭文件。
4.3.1 fopen函数
//打开⽂件 --- 打开文件名在参数filename中指定的文件，并将其与一个流关联，该流可以在将来的操作中通过返回的FILE指针识别。
FILE * fopen ( const char * filename, const char * mode );
filename：要打开的文件名称的C字符串（故需要用" "包含起来）
返回的指针可以通过调用fclose或freopen与文件解除关联。所有打开的文件在正常程序终止时自动关闭。
fopen函数的返回值：
如果文件被成功打开，该函数返回一个指向file对象的指针，该指针可用于在以后的操作中识别流。
否则，返回空指针。
mode表示文件的打开模式，下面都是文件的打开模式：
用w操作时，若文件不存在，会建立一个新的文件，若文件存在，就会把文件原有的内容清空
4.3.2 fclose函数
//关闭⽂件 ---关闭与流关联的文件并解除关联。
int fclose ( FILE * stream );
stream:指向FILE对象的指针，该对象指定要关闭的流。
fclose函数的返回值：
1、如果流被成功关闭，则返回一个零值。
2、如果失败，则返回EOF。
所有与流关联的内部缓冲区都将与流解除关联并刷新:任何未写入的输出缓冲区的内容将被写入，而任何未读的输入缓冲区的内容将被丢弃。（该句可以在末尾了解文件缓冲区一知识后再进行了解)
所有打开的文件在正常程序终止时自动关闭。但还是要用fclose来关闭，fopen与fclose是成对出现的！
例如：当你在做一些作业时，需要用到一系列的工具，所以你在自己的电脑上打开一堆程序，方便使用。Two years ago，你累了，想玩会游戏，又没关掉你打开的工具，这时候可能就无法成功打开游戏，这是因为内存空间被占用了，不足以支持打开游戏所需要的空间（没错，就是我自己）
#include<stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "w");//若该文件在该路径下不存在，"w"操作会自动生成一个”test.txt"文件
if (pf == NULL)//若返回的值为NULL，则阐述错误并结束进程
{
perror("fopen");
return 1;
}
//读文件
//关闭文件
fclose(pf);//不会把pf置为空
pf = NULL;//因此将其置为空指针，防止其成为野指针
return 0;
}
5. 文件的顺序读写
5.1 顺序读写函数介绍
上面说的适用于所有输入流⼀般指适用于标准输入流和其他输入流（如文件输入流）；所有输出流⼀般指适用于标准输出流和其他输出流（如文件输出流）。
下面讲到的流可以认为是文件！（容易理解）
5.1.1 fputc函数
//将字符写入流 ---- 将一个字符写入流并推进位置指示器。（相当于光标向前移动）
int fputc ( int character, FILE * stream );
character：该值在写入时在内部转换为无符号字符。
stream：指向标识输出流的FILE对象的指针。
fputc函数的返回值：
如果成功，则返回所写的字符。
如果发生写错误，则返回EOF并设置错误指示器(ferror)。
/* fputc example: alphabet writer */
#include <stdio.h>
int main()
{
FILE* pFile;//文件指针变量
char c;
//打开文件
pFile = fopen("alphabet.txt", "w");//以"w"的形式打开文件，进行写操作
//写文件
if (pFile != NULL)
{
for (c = 'A'; c <= 'Z'; c++)
{
fputc(c, pFile);//将'A' ~'Z'的字符全部写进该文件中
}
//关闭文件
fclose(pFile);//关闭文件
pFile=NULL;
}
return 0;
}
5.1.2 fgetc函数
//从流中获取字符 --- 返回指定流的内部文件位置指示符当前指向的字符。然后将内部文件位置指示符推进到下一个字符。
int fgetc ( FILE * stream );
stream:指向标识输入流的FILE对象的指针。
fgetc函数的返回值：
如果读取成功，则返回所读取的字符的ASCII码值。
返回类型为int，以适应特殊值EOF，它表示失败:
如果位置指示器位于文件末尾，则该函数返回EOF并设置流的EOF指示器(feof)。
如果发生其他一些读取错误，该函数也返回EOF，但会设置其错误指示器(ferror)。
/* fgetc example: money counter */
#include <stdio.h>
int main()
{
FILE* pFile;
int c;
int n = 0;
//打开文件
pFile = fopen("myfile.txt", "r");//从文件myfile.txt中读数据，在该情况下，要确保在该程序所在路径下含有该文件，否则会出现错误
if (pFile == NULL)
{
perror("Error opening file");//若打开失败返回空指针并报错，结束进程
return;
}
else
{
do
{
c = fgetc(pFile);//从文件中读取字符，将值赋给字符变量c
if (c == '$')
{
n++;
}
} while (c != EOF);//根据fgetc的返回值设置的循环条件
//关闭文件
fclose(pFile);
printf("The file contains %d dollar sign characters ($).\n", n);
}
return 0;
}
这个程序一个字符一个字符地读取一个名为myfile.txt的现有文件，并使用n变量计算文件中包含多少美元字符($)。
5.1.3 fputs函数
将字符串写入流 --- 将由str指向的C字符串写入流。
int fputs (const char * str, FILE * stream);
str:包含要写入流的内容的C字符串。
stream:指向标识输出流的FILE对象的指针。
函数从指定的地址(str)开始复制，直到到达结束的空字符(‘\0’)。这个终止的空字符不会复制到流中。
注意，fputs与puts的不同之处不仅在于可以指定目标流，而且fputs不会写入额外的字符，而puts会自动在末尾附加一个换行符。
返回值：
如果成功，则返回一个非负值。
如果出现错误，该函数返回EOF并设置错误指示器(ferror)。
#include <stdio.h>
int main()
{
//打开文件
FILE* pFile;//文件指针变量
pFile = fopen("alphabet.txt", "w");//以“w（写）”的形式打开alphabet.txt文件
if (pFile == NULL)
{
perror("fopen");
return;
}
//写文件
fputs("hello world", pFile);//将字符串hello world写入指定文件
fputs("hello Sir", pFile);//将字符串hello Sir写入指定文件
//关闭文件
fclose(pFile);
pFile = NULL;
return 0;
}
5.1.4 fgets函数
//从流中获取字符串 --- 从流中读取字符，并将其作为C字符串存储到str中，直到读取(num-1)个字符，或者到达换行符或文件结束符，以先发生的为准。
char * fgets ( char * str, int num, FILE * stream );
str：指向字符数组的指针，在该数组中复制所读的字符串。
num：要复制到str中的最大字符数(包括结束的空字符)。
stream：指向标识输入流的FILE对象的指针。Stdin可以用作从标准输入中读取的参数。
读取num-1个字符，因为要留一个位置给’\0’
换行符使fgets停止读取，但它被函数认为是一个有效字符，并包含在复制到str的字符串中。
在复制到str的字符之后，将自动追加一个终止null字符。
请注意，fgets与gets有很大的不同:fgets不仅接受流参数，而且允许指定str的最大长度，并在字符串中包含任何结束换行符。
返回值：
如果成功，函数返回str。
如果在尝试读取字符时遇到文件结束符，则设置eof指示符(feof)。如果这发生在可以读取任何字符之前，则返回的指针是空指针(并且str的内容保持不变)。
如果发生读错误，则设置错误指示器(ferror)并返回空指针(但是str所指向的内容可能已经更改)。
#include<stdio.h>
int main()
{
// 打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
char arr[20] = "****************";
fgets(arr, 10, pf);
//2. 关闭文件
fclose(pf);
pf = NULL;
return 0;
}
#include<stdio.h>
int main()
{
//1. 打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
char arr[20] = { 0 };
while (fgets(arr, 20, pf) != NULL)
{
printf("%s", arr);
}
//2. 关闭文件
fclose(pf);
pf = NULL;
return 0;
}
5.1.5 fprintf函数
int fprintf ( FILE * stream, const char * format, ... );
如果成功，则返回写入的字符总数。
如果出现写错误，则设置错误指示器(ferror)并返回一个负数。
如果在写宽字符时出现多字节字符编码错误，则errno被设置为EILSEQ并返回一个负数。
#include <stdio.h>
struct S
{
char name[20];
int age;
float score;
};
int main()
{
struct S s = { "张三", 20, 65.5f };
//想把s中的数据存放在文件中
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件 - 是以文本的形式写进去的
//printf("%s %d %f", s.name, s.age, s.score);//将数据打印在显示器上
fprintf(pf, "%s %d %f", s.name, s.age, s.score);//多了一个参数，将数据写到指定的流中
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
5.1.6 fscanf函数
int fscanf ( FILE * stream, const char * format, ... );
如果成功，该函数返回参数列表中成功填充的项数。
如果在读取时发生读取错误或到达文件末尾，则设置适当的指示符(feof或ferror)。并且，如果在成功读取任何数据之前发生任何情况，则返回EOF。
如果在解释宽字符时发生编码错误，该函数将errno设置为EILSEQ。
#include <stdio.h>
struct S
{
char name[20];
int age;
float score;
};
int main()
{
struct S s = { 0 };
//想从文件test.txt中读取数据放在s中
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件 -- 需按照对应格式进行读取
fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));//从指定文件中读取数据存放在结构体成员中
//打印在屏幕上看看 -- 注意需用对格式符
printf("%s %d %f\n", s.name, s.age, s.score);
fprintf(stdout, "%s %d %f\n", s.name, s.age, s.score);//指定输出到标准输出流
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
5.1.7 sscanf与sprintf
//将格式化的数据写入字符串
int sprintf ( char * str, const char * format, ... );
//组成一个字符串，但不是打印，而是将内容作为C字符串存储在str指向的缓冲区中。
//在内容之后自动附加一个终止字符-- '\0'。
str:指向存储结果c字串的缓冲区的指针。
返回值：
如果成功，则返回写入的字符总数。此计数不包括自动附加在字符串末尾的额外空字符。
如果失败，则返回一个负数。
//从字符串中读取格式化数据
int sscanf ( const char * s, const char * format, ...);
返回值:
如果成功，该函数返回参数列表中成功填充的项数。在匹配失败的情况下，该计数可以匹配预期的项目数，也可以更少(甚至为零)。
如果在成功解释任何数据之前出现输入失败，则返回EOF。
#include <stdio.h>
struct S
{
char name[20];
int age;
float score;
};
int main()
{
char buf[200] = { 0 };
struct S s = { "张三", 20, 65.5f };
sprintf(buf, "%s %d %f", s.name, s.age, s.score);//将格式化数据写进字符串
printf("1以字符串的形式: %s\n", buf);//1
struct S t = {0};
sscanf(buf, "%s %d %f", t.name, &(t.age), &(t.score));//从字符串中读取格式化数据
printf("2按照格式打印 : %s %d %f\n", t.name, t.age, t.score);//2
return 0;
}
5.1.8 fwrite函数（二进制输出）
//将数据块写入流 --- 将由count元素组成的数组(每个元素的大小为size字节)从ptr所指向的内存块写入流中的当前位置。
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
流的位置指示器（光标）按写入的总字节数前进。
ptr：指向要写入的元素数组的指针，转换为const void*类型。
size：要写入的每个元素的字节大小。
count：元素的数目，每个元素的大小为size字节。
stream：指向指定输出流的FILE对象的指针。
返回值：
返回成功写入的元素总数。
如果该数字与count参数不同，则写入错误将阻止函数完成。在这种情况下，将为流设置错误指示器(ferror)。
如果size或count为零，则函数返回零，错误指示器保持不变。
#include <stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5 };
FILE*pf = fopen("test.txt", "wb");//二进制形式写入文件
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写数据
int sz = sizeof(arr) / sizeof(arr[0]);
fwrite(arr, sizeof(arr[0]), sz, pf);//以二进制的形式写进去的
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
5.1.9 fread函数（二进制输入）
//从流中读取数据块 --- 从流中读取一个由count元素组成的数组，每个元素的大小为size字节，并将它们存储在ptr指定的内存块中。
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
流的位置指示器（光标）按读取的总字节数前进。
ptr：指向大小至少为(size*count)字节的内存块的指针，转换为void*。
size：要读取的每个元素的大小(以字节为单位)。
count：元素的数目，每个元素的大小为size字节。
stream：指向指定输入流的FILE对象的指针。
返回值：
返回成功读取的元素总数。
如果这个数字与count参数不同，则要么发生了读取错误，要么在读取时到达了文件末尾。在这两种情况下，都设置了适当的指示器，可以分别用ferror和feof进行检查。
如果size或count为零，则函数返回零，流状态和ptr所指向的内容保持不变。
#include <stdio.h>
//以二进制的形式读取
int main()
{
int arr[5] = {0};
FILE* pf = fopen("test.txt", "rb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读数据
fread(arr, sizeof(arr[0]), 5, pf);//以二进制的形式写进去的
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", arr[i]);//1 2 3 4 5
}
fclose(pf);
pf = NULL;
return 0;
}
当我们不知读取个数是多少时，我们可以采用下面这种做法
//由于fread函数的返回值为成功读取的个数，所以当读取个数为0时，就会退出
#include <stdio.h>
int main()
{
int arr[5] = { 0 };
//打开文件
FILE* pf = fopen("test.txt", "rb");//以二进制形式从文件中读取数据
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读数据-以二进制的形式写进去的
int i = 0;
while (fread(&arr[i], sizeof(int), 1, pf))//该函数返回的是成功读取元素的个数，读取成功返回1，错误为0
{
printf("%d ", arr[i]);
i++;
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
6. 文件的随机读写
6.1 fseek
根据文件指针的位置和偏移量来定位文件指针（文件内容的光标）。
int fseek ( FILE * stream, long int offset, int origin );
stream：指向标识流的FILE对象的指针。
offset：相对于origin位置的偏移量
origin：有三种选择 --- >
SEEK_SET --- 文件起始位置
SEEK_CUR --- 文件指针的当前位置
SEEK_END --- 文件末尾
返回值：
如果成功，函数返回0。
否则，它返回非零值。
如果发生读写错误，则设置错误指示器(ferror)。
#include <stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "r");//假设test.txt文件中存放着abcdefghi
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = fgetc(pf);
printf("%c\n", ch);//a
//此时想读取字符f
//fseek(pf, 4, SEEK_CUR);//SEEK_CUR --- 文件指针当前位置，由上面可知，此时光标位于b前面，若要读取字符f，则需向后偏移4个字符
//fseek(pf, 5, SEEK_SET);//SEEK_SET --- 文件起始位置，光标从字符a前面开始，所以需偏移5个字符
fseek(pf, -4, SEEK_END);//SEEK_END --- 文件末尾，光标位于文件末尾，要读取f，需倒着往后偏移，偏移量为-4
ch = fgetc(pf);
printf("%c\n", ch);//f
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
6.2 ftell
返回⽂件指针相对于起始位置的偏移量
1 long int ftell ( FILE * stream );
返回流的位置指示器的当前值。
如果成功，则返回位置指示器的当前值。
如果失败，则返回-1L，并将errno设置为特定于系统的正值。
#include<stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
fseek(pf, -2, SEEK_END);
printf("%d\n", ftell(pf));//输出此时文件指针相对于起始位置的偏移量（也可以是光标相对起始位置的偏移量）
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
6.3 rewind
让文件指针的位置回到文件的起始位置
1 void rewind ( FILE * stream );
在成功调用此函数后，与流相关的文件结束和错误内部指示器将被清除
#include<stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "r");//假设文件中存放着abcdefghi
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
fseek(pf, -2, SEEK_END);
char ch = getc(pf);
printf("%c\n", ch);//输出结果为h
rewind(pf);//使⽂件指针的位置回到⽂件的起始位置
ch = getc(pf);
printf("%c\n", ch);//输出结果为a
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
7. 文件读取结束的判定
7.1 被错误使用的 feof
牢记：在文件读取过程中，不能用feof函数的返回值直接来判断文件的是否结束。
feof 的作用是：当文件读取结束的时候，判断读取结束的原因是否是：遇到文件尾结束。
1、文本文件读取是否结束，判断返回值是否为EOF（fgetc），或者NULL（fgets），例如：
• fgetc 判断是否为 EOF .
• fgets 判断返回值是否为 NULL .
2、二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。例如：
• fread判断返回值是否小于实际要读的个数。
7.1.1 feof与ferroe
int feof ( FILE * stream );
stream：指向标识流的FILE对象的指针。
返回值：
如果设置了与流关联的文件结束指示符，则返回一个非零值。
否则，返回0。
检查是否设置了与流关联的文件结束符指示符，如果设置了，则返回一个不同于零的值。
int ferror ( FILE * stream );
stream：指向标识流的FILE对象的指针。
检查是否设置了与流关联的错误指示符，如果设置了，则返回一个不同于零的值。
返回值
如果设置了与流关联的错误指示符，则返回一个非零值。
否则，返回0。
#include<stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "r");//假设文件中存放着ABCDEFGHIJKLMNOPQRSTUVWXYZ
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
char ch = 0;
while ((ch = getc(pf)) != EOF)
{
printf("%c", ch);
}
printf("\n");
if (feof(pf))
{
printf("遇到文件末尾，读取正常结束\n");
}
else if (ferror(pf))
{
perror("getc");
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
8. ⽂件缓冲区
ANSIC 标准采⽤“缓冲⽂件系统” 处理的数据⽂件的，所谓缓冲⽂件系统是指系统⾃动地在内存中为程序中每⼀个正在使⽤的⽂件开辟⼀块“⽂件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才⼀起送到磁盘上。如果从磁盘向计算机读⼊数据，则从磁盘⽂件中读取数据输⼊到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的⼤⼩根据C编译系统决定的。
#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
FILE* pf = fopen("test.txt", "w");
fputs("abcdef", pf);//先将代码放在输出缓冲区
printf("睡眠10秒-已经写数据了，打开test.txt⽂件，发现⽂件没有内容\n");
Sleep(10000);
printf("刷新缓冲区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到⽂件（磁盘）
//注：fflush 在⾼版本的VS上不能使⽤了
printf("再睡眠10秒-此时，再次打开test.txt⽂件，⽂件有内容了\n");
Sleep(10000);
fclose(pf);
//注：fclose在关闭⽂件的时候，也会刷新缓冲区
pf = NULL;
return 0;
}
这⾥可以得出⼀个结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题。