一、为什么使用文件
在学习完结构体后，为了检验学习成果，我们写了一个通讯录的小程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中的，当程序退出的时候，通讯录中的数据就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。
二、什么是文件
- 磁盘上的文件是文件。
- 在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
2.1 程序文件
包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
2.2 数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。
?在前面我们所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
?其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
2.3 文件名
- 一个文件要有一个唯一的文件标识，以便用户识别和引用
- 文件名包含3部分：文件路径+文件名主干+文件后缀
- 例如： c:\code\test.txt
三、文件的打开和关闭
3.1 文件指针
缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名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指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。
?比如：
3.2 文件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。
ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件：
//打开文件 FILE * fopen ( const char * filename, const char * mode ); //关闭文件 int fclose ( FILE * stream );
???打开方式如下：
?示例代码：
#include <stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//关闭文件
fclose(pf);
pf == NULL;
return 0;
}
注意：我们平常所写的程序保存数据是保存在内存当中的，而我们想把内存当中的数据放在文件当中去，文件又是在硬盘上的，所以把内存当中的数据往硬盘上放的这个操作叫做写文件或输出操作，把文件当中的数据往内存里边放的操作叫读文件或输入操作。
四、文件的顺序读写
?深入理解 “流”：
- 在C语言中，流可以分为文件流和输入输出流。
- 流是一个高度抽象的概念，我们可以把它理解为信息流或者水流，在写文件的过程中，会有很多的数据，这些数据可能会传输到不同的地方去，比如说显示到屏幕上，存到硬盘上，传到网络上等等，这些统称为外部设备，不同的外部设备操作方式也不同。
- 要把数据传到各种外部设备上去，就对程序员有较高的要求了，这时候就有人想把这个过程简化一下，在外部设备和数据之间抽象一个东西，这个东西我们就叫做流，它里边流淌的都是数据，程序员现在只关心把数据怎么放在流里边，至于流怎么把数据放在外部设备上去，那就不是我们要操心的事儿了，这样一来，整个过程就简单了许多。
- 回忆一下我们曾经用scanf从键盘上读取数据，或用printf向屏幕上打印数据，直接就操作了，好像没有打开键盘或打开屏幕的操作，这是因为C语言程序只要运行起来，就会默认打开三个流，分别为：标准输入流 --- stdin、标准输出流 --- stdout、标准错误流 --- stderr。因为scanf从键盘上读取数据其实就是从标准输入流里边读取数据，而printf向屏幕上打印数据就是向标准输出流里边打印数据，所以我们读取数据或输入数据的时候并没有发现打开键盘或打开屏幕的操作。
- 文件流是用于文件读写操作的数据流，它可以从文件中读取数据，也可以向文件中写入数据，另外，文件流需要指定文件路径和文件名，而标准输出流不需要指定文件路径，直接输出到屏幕上。
?使用输出流向屏幕输出26个英文字母：
int main()
{
char ch = 0;
for (ch = 'a'; ch < 'z'; ch++)
{
if (ch % 5 == 0)
fputc('\n', stdout);
fputc(ch, stdout);
}
return 0;
}
?文件的顺序读写函数介绍：
?fputc函数：
1.函数原型：
int fputc ( int character, FILE * stream );
2.功能：
向指定的文件流中写入一个字符。
3.示例：
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fputc('a', pf);
fputc('b', pf);
fputc('c', pf);
fputc('d', pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
在上述程序中，刚开始我们打开一个文件，它里边什么都没有 ，但是我有一个文件指针是指向这个文件的起始位置的（这儿所说的文件指针是指标记字符位置的指针即光标，而不是pf）；如果打开成功，接下来就要写文件，最开始文件指针是指向第一个位置的，所以fputc把a写了进去，这时候文件指针的状态就会更新，指向a的后边，然后fputc再把b写进去，每一次进行写操作后，文件指针的位置就要发生变化，直到把所有的字符都写进去。然后fclose关闭文件，将文件保存起来。
?fgetc函数：
1.函数原型：
int fgetc ( FILE * stream );
stream：要从中读取字符的文件流。
2.功能：
从指定的文件流中读取一个字符，并返回其ASCII值。
3.示例：
程序运行起来后，先打开文件，如果成功，就开始读文件，读文件的时候光标默认在最前面，当fgetc读一个字符的时候，光标指向的那个位置为a，所以就返回字符a的ASCII值，然后打印在屏幕上，以同样的步骤操作三次，就会将a、b、c分别打印在屏幕上，紧接着关闭文件。
?fputs函数:
1.函数原型：
int fputs ( const char * str, FILE * stream );
str：要写入文件的字符串。stream：要写入的文件流。
2.功能：
向指定的文件流中写入一行文本。
3.示例：
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
//写到文件中去
fputs("hello\n", pf);
fputs("world!\n", pf);
//写到屏幕上去
fputs("hello\n", stdout);
fputs("world!\n", stdout);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
?fgets函数：
1.函数原型：
char * fgets ( char * str, int num, FILE * stream );str：指向用于存储读取字符串的字符数组的指针。num：要读取的最大字符数（num - 1个）。stream：要从中读取行的文件流。
2.功能：
从指定的文件流中读取一行文本，并将其存储到指定的字符串中。
3.示例：
int main(){//打开文件FILE* pf = fopen("test.txt", "r");if (pf == NULL){perror("fopen");return 1;}//读文件char arr[10] = { 0 };fgets(arr, 3, pf);//关闭文件fclose(pf);pf = NULL;return 0;}
因为它读取的最大字符数是num - 1个，所以只存储了前两个字符。
?fprintf函数：
1.函数原型：
int fprintf ( FILE * stream, const char * format, ... );
stream：要写入数据的文件流。format：格式字符串，指定了要写入的数据的格式。...：要写入数据的变量列表。
2.功能：
向指定的文件流中按照指定格式写入数据。
3.示例：
struct S
{
float f;
char c;
int n;
};
int main()
{
struct S s = { 3.14f, 'w', 100 };
//打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fprintf(pf, "%f %c %d", s.f, s.c, s.n);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
?fscanf函数：
1.函数原型：
int fscanf ( FILE * stream, const char * format, ... );stream：要从中读取数据的文件流。format：格式字符串，指定了要读取的数据的格式。...：要读取的数据的变量列表。
2.功能：
从指定的文件流中按照指定的格式读取数据。
3.示例：
struct S
{
float f;
char c;
int n;
};
int main()
{
struct S s = { 0 };
//打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fscanf(pf, "%f %c %d", &(s.f), &(s.c), &(s.n));
printf("%f %c %d\n", s.f, s.c, s.n);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
?fwrite函数：
1.函数原型：
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
- ptr：指向要写入的数据的缓冲区的指针。
- size：每个数据的字节数。
- count：要写入的数据块的数量。
- stream：要写入数据的文件流。
2.功能：
向指定的文件流中写入指定数量的数据块。
3.示例：
//二进制的方式写进文件
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//打开文件
FILE* pf = fopen("text.txt", "wb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//二进制的写文件
fwrite(arr, sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
可以看到写进去的值都变成了二进制，我们看不懂，但是我们也可以以二进制的方式读取文件。
fread函数：
1.函数原型：
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
- ptr：指向存储读取数据的缓冲区的指针。
- size：每个数据的字节数。
- count：要读取的数据块的数量。
- stream：要读取数据的文件流。
2.功能：
从指定的文件流中读取指定数量的数据块。
3.示例：
//二进制的方式读取文件
int main()
{
int arr[10] = { 0 };
//打开文件
FILE* pf = fopen("text.txt", "rb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//二进制的读文件
fread(arr, sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
?对比一组函数：
scanf、fscanf、sscanf
printf、fprintf、sprintf
scanf是格式化的输入函数，针对的是标准输入流 （键盘）；printf是格式化的输出函数，针对的是标准输出流（屏幕）；综上所述，scanf和printf是针对标准输入/输出流的格式化输入/输出函数。
fscanf是针对所有输入流（文件流、标准输入流）的格式化输入函数；sprintf是针对所有输出流（文件流、标准输出流）的格式化输出函数。
sprintf是把格式化的数据转化换成字符串；sscanf是将字符串转换成格式化数据。
struct S
{
float f;
char c;
int n;
};
int main()
{
struct S s = { 3.14f, 'c', 100 };
char arr[100] = { 0 };
sprintf(arr, "%f %c %d", s.f, s.c, s.n);
printf("%s\n", arr);
struct S tmp = { 0 };
sscanf(arr, "%f %c %d", &(tmp.f), &(tmp.c), &(tmp.n));
printf("%f\n", tmp.f);
printf("%c\n", tmp.c);
printf("%d\n", tmp.n);
return 0;
}
五、文件的随机读写
5.1 fseek函数:
1.函数原型：
int fseek ( FILE * stream, long int offset, int origin );
stream：指向FILE对象的指针，它标识了要定位的文件。
offset：偏移量，即要移动的字节数。可以为正数、负数或0，具体取决于origin参数。
origin：定位的起始位置，可以是下列常量之一：
SEEK_SET：从文件开头开始偏移。SEEK_CUR：从当前位置开始偏移。SEEK_END：从文件末尾开始偏移。
返回值：如果定位成功，fseek函数返回0；如果失败，返回非零值。
2.功能：
fseek函数用于设置文件位置指针，以便在文件中进行定位。它可以将文件位置指针设置到文件的任意位置，从而可以进行读取或写入操作。
3.示例：
int main()
{
//打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
//ch = fgetc(pf);
//printf("%c\n", ch);//c
//fseek(pf, -2, SEEK_CUR);//从当前位置开始偏移
//fseek(pf, 0, SEEK_SET);//从文件的开头开始偏移
fseek(pf, -6, SEEK_END);//从文件的末尾开始偏移
ch = fgetc(pf);
printf("%c\n", ch);//a
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
我的文件中放着一串字符串“abcdef”， 现在我想从中读取字符出来，用fgetc函数就可以，但我想让它第三个字符读的是a，这个时候就可以用fseek函数。
5.2 ftell函数：
1.函数原型：
long int ftell ( FILE * stream );stream：指向FILE对象的指针，用于标识要获取位置的文件。返回值：返回当前位置相对于文件开头的偏移量，如果出现错误则返回-1。
2. 功能：
用于获取文件位置指针的当前位置，即返回当前位置相对于文件开头的偏移量。
3.示例：
int main()
{
//打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
ch = fgetc(pf);
printf("%c\n", ch);//c
int pos = ftell(pf);
printf("pos= %d\n", pos);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
5.3 rewind函数：
1. 函数原型：
void rewind ( FILE * stream ); stream：指向FILE对象的指针，用于标识要重新定位的文件。
2.功能：
用于将文件位置指针重新定位到文件的开头，即相当于调用fseek(stream, 0, SEEK_SET)。
3.示例：
int main()
{
//打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
//ch = fgetc(pf);
//printf("%c\n", ch);//c
rewind(pf);
ch = fgetc(pf);
printf("%c\n", ch);//a
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
六、文本文件和二进制文件
- 根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
- 数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
- 如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
那一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而以二进制形式输出，则在磁盘上只占4个字节（VS2013测试）。
?测试代码：
我们将10000以 二进制的形式写到文件中，就是上述效果，我们自己是看不懂的，但VS却能看懂，具体操作步骤如下图：
int main()
{
int a = 10000;
FILE* pf = fopen("test.txt", "wb");
//二进制的形式写到文件中
fwrite(&a, 4, 1, pf);
fclose(pf);
pf = NULL;
return 0;
}
将10000转换成二进制为 0010 0111 0001 0000，这是16个二进制位，不够32位，我们给它补齐0000 0000 0000 0000 0010 0111 0001 0000，每4个二进制位转换成1个16进制位，就为0x00 0x00 0x27 0x10，那在内存中以小端方式存放就为10 27 00 00。
七、文件读取结束的判定
7.1 文本文件的读取结束判定
文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）。fgetc 判断是否为 EOF 。fgets 判断返回值是否为 NULL。
ferror：在文件读取结束后，用来判断文件是否因为读取过程中遇到错误而结束。feof：在文件读取结束后，用来判断文件是否因为读取过程中遇到文件结束标志而结束。牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件是否结束。而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束 。
示例：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int c; // 注意：是int而非char，因为要求处理EOF，而EOF实际是-1，是个整型值
FILE* fp = fopen("test.txt", "r");
if (!fp)
{
perror("fopen");
return 1;
}
//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);
}
7.2 二进制文件的读取结束判定
fread函数判断返回值是否小于实际要读的个数。
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );fread要求读取count个大小为size字节的数据。如果真的读取到count个数据，函数返回count。如果没有读取到count个数据，返回的是真实读取到的完整的数据个数。
示例：
#include <stdio.h>
enum { SIZE = 5 };
int main()
{
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);
return 0;
}
八、文件缓冲区
ANSIC 标准采用“缓冲文件系统”处理数据文件，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等），缓冲区的大小根据C编译系统决定。
#include <stdio.h>
#include <windows.h>
//VS2019 WIN10环境测试
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语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题。
