目录
前言
C语言原生的对于文件的操作是相对较少的，一般是在它上面再封装一层函数，使其使用起来更方便简单。
1. 为什么使用文件
在通讯录的程序中，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，打印的数据也是内存中的数据。当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又要重新录入，如果使用这样的通讯录就很难受。我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，一般数据持久化的方法有：把数据存放在磁盘文件、存放到数据库等方式。使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。
2. 什么是文件
磁盘（是C盘，也称硬盘）上的文件是文件。
但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
2.1 程序文件
包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
.bat也是程序文件，只要与程序有关的，写代码完成的都可以认为是程序文件。后缀为.c的是C语言的程序文件，当对程序文件进行编译（生成解决方案）的时候，是编译链接操作，此时在后台就会生成Debug文件夹，在Debug文件夹中可以看到后缀为.exe的文件，这是编译所产生的可执行程序，这个可执行程序也是程序文件；在Debug文件夹中还可以看到.obj的文件，是目标文件，是程序在编译过程中生成的临时文件，把目标文件经过链接就会生成.exe的可执行程序。
2.2 数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，
或者输出内容的文件。
程序文件和数据文件的关系：
在test.c中写C语言代码，若通过C语言文件去操作（通过程序把数据写到date.txt文件中，把数据123456789写到date.txt文件中，test.c中放的是代码，是程序文件，通过test.c去操作date.txt文件——向date.txt文件中写数据123456789，当然可以从date.txt中拿走或读取数据123456789，此时操作的date.txt就是数据文件。操作的文件名叫test2.c也可以，向test2.c中写数据和读或拿数据，此时test2.c也是数据文件。
本篇博文讨论的是数据文件——如何通过代码来操作数据文件。
在之前博文所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
意思是写test.c这样的代码，其实是从键盘上获取数据（键盘读的数据放到程序中），当程序想输出的时候则打印数据在显示器上，此时操作的对象是键盘和显示器。
其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上的文件。
2.3 文件名
一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：文件路径+文件名主干+文件后缀。
例如文件名：c:\code\test.txt
意思是c盘的code目录下test.txt文件，c:\code\是文件路径，test是文件主干名，.txt是文件后缀。
为了方便起见，文件标识常被称为文件名。
3. 实现文件的打开和关闭
对文件进行操作就涉及文件的打开和关闭，在文件中写数据或从文件中哪数据需要打开文件去使用，使用完之后关闭。
3.1 文件指针
缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE。
当程序去操作一个文件如data.txt的时候：
参考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来关闭文件。
1、打开文件：
FILE * fopen ( const char * filename, const char * mode );filename——文件名；
mode——打开方式；mode（文件使用方式）有：
"r"
Opens for reading. If the file does not exist or cannot be found, the fopen call fails.
如果文件不存在或没能找到，则fopen会调用失败。
"w"
Opens an empty file for writing. If the given file exists, its contents are destroyed.
若要写的文件已经存在，则打开该文件的一瞬间会把文件的内容都清理掉，然后重新写内容。
——取自MSDN一部分
如果要打开一个test.txt文件（该文件默认在test.c路径下打开），以“w”形式打开：
（注意使用是双引号，双引号引的是字符串，单引号引的是单引号）
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
return 0;
}若原本没有test.txt文件，则运行该程序后会在test.c的路径下自动生成一个test.txt文件。
若原本在已经有test.txt这个文件并且已经写入数据则运行该程序后就会把数据清理掉。
"test.txt"——默认路径，是程序所在路径下。
如果要打开其他路径的文件——则告诉文件的路径：
#include <stdio.h>
#include <stdio.h>
int main()
{
FILE* pf = fopen("c:\\2022code\\test.txt", "w");
//加一个\避免是转义字符中的\,两个\就是一个\
return 0;
}
上述交代路径：c:\2022code\
"c:\\2022code\\test.txt"，——绝对路径的写法（清楚交代路径）其意思是c盘的2022code目录下test.txt文件，c:\2022code\是文件路径，test是文件主干名，.txt是文件后缀。
fopen()函数返回的是FILE* pf的指针，这个指针是什么？
对于：
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
return 0;
}
当fopen()函数打开text.txt文件时同时创建一个和这个文件关联的文件信息区，同时自动填充该文件的相关信息，文件信息区就是一个FILE结构体变量，fopen()函数返回的是FILE变量的地址（才能放到FILE*的指针中去），实际返回的就是文件信息区的起始地址。
即只要打开一个文件就会创建一个该文件对应的文件信息区，同时返回这个文件信息区的起始地址（文件信息区的起始地址放到一个文件指针中，该文件指针指向的是一个结构体变量）。
fopen()函数会调用失败：（即打开文件失败）
Return Value
Each of these functions returns a pointer to the open file. A null pointer value indicates an error.
发生错误会返回空指针，则意味着需要对fopen()函数返回值检测判断。
#include <stdio.h>
int main()
{
//打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
printf("打开文件失败\n");
return 0;
}
//打开文件成功
//写文件：
//关闭文件？
return 0;
}
2、关闭文件：
int fclose ( FILE * stream );fclose()函数的参数是FILE*的指针，就是前面fopen()函数返回的FILE的起始地址。就是若想要关闭的是pf所关联的文件，则就把pf的值传给fclose。
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
printf("打开文件失败\n");
return 0;
}
fclose(pf);
pf = NULL;
return 0;
}具体打开方式如下：
这里rb和wb中的输入和输出的意思是：
“输入数据”——是把文件的内容放到内存中，向内存输入。
“输出数据”——是把内存中的数据放到文件中。
举例：
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("打开文件失败\n");
return 0;
}
//读文件
fclose(pf);
pf = NULL;
return 0;
}//打开文件失败
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
/*printf("打开文件失败\n");*/
//打印失败的原因——把错误码errno翻译成错误信息，错误信息是strerror告诉的
printf("%s\n", strerror(errno));
return 0;
}
//读文件
fclose(pf);
pf = NULL;
return 0;
}//No such file or directory没有文件或文件夹
4. 文件的顺序读写
看一组函数：fgetc()函数和fputc()函数：
4.1 字符的fputc()写与fgetc()读
1、写字符：
字符输出函数fputc()，把内存中的字符写到文件中。（把字符写入流中）
int fputc( int c, FILE *stream );
参数c是要被写的字符。
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写文件——顺序写
fputc('a', pf);//向文件中写入a
fputc('b', pf);
fputc('c', pf);
fclose(pf);
pf = NULL;
return 0;
}实现效果：
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写文件
char ch = 0;
for (ch = 'a'; ch <= 'z'; ch++)
{
fputc(ch, pf);
}
fclose(pf);
pf = NULL;
return 0;
}//在data.txt文件中abcdefghijklmnopqrstuvwxyz每个字符的ASCC码值差1。
在每一个C语言程序中，只要运行起来就默认打开三个流：
stdin——标准输入流；从键盘上读取信息就是从标准输入流中读取。
stdout——标准输出流；把信息打印在屏幕上就是打印在标准输出流上。
stderr——标准错误流。
这三个流的类型都是FILE*类型的。
fputc()函数适用于所有输入流。
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写文件
char ch = 0;
for (ch = 'a'; ch <= 'z'; ch++)
{
/*fputc(ch, pf);*/
fputc(ch, stdout);
}
fclose(pf);
pf = NULL;
return 0;
}//在屏幕上打印出abcdefghijklmnopqrstuvwxyz2、读字符：
字符输入函数fgetc()，从文件中读一个字符到内存中；
int fgetc( FILE *stream );
读取成功返回的是所读字符的ASCII码值，是整型。
读取失败如遇到文件结束或错误就会返回EOF。
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读文件——顺序读
int ch = fgetc(pf);//去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;
}//从data.txt文件(内容是abcdeghi)中读字符，打印的是：a,b,c,d
注意：
char ch = 0;
while ((ch = fgetc(pf)) != EOF)
{
printf("%c ", ch);
}不能写成char ch = 0;虽然fgetc()函数返回的是字符的ASCII码值，但是因为函数读取失败时会返回EOF，而EOF不是ASCII码值，是-1，是整数，则char存不下，所以即能接收整型EOF又要接收字符的ASCII码值就写成int ch = 0;
也不能写成：
int ch = 0;
while (ch == fgetc(pf))
{
printf("%c ", ch);
}当函数读取失败时返回EOF，EOF值为-1，非0为真，循环不会结束。
4.2 字符串的fputs()写与fgets()读
看一组函数：fgets()函数和fputs()函数
1、fputs()函数——写入字符串
int fputs( const char *string, FILE *stream );
第一个参数是写入的字符串，第二个参数是FILE*指针
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写一行
fputs("hello world", pf);
fclose(pf);
pf = NULL;
return 0;
}//文件中：hello world#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写一行
fputs("hello world\n", pf);
fputs("hehe\n", pf);
fclose(pf);
pf = NULL;
return 0;
}//文件中：
//hello world
//hehe
fputs()函数适用于所有输入流，则：
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写一行
fputs("hello world\n", stdout);
fputs("hehe\n", stdout);
fclose(pf);
pf = NULL;
return 0;
}//屏幕上：
//hello world
//hehe2、fgets()函数——从文件中读数据
char *fgets( char *string, int n, FILE *stream );
第二个参数是最多能读的字符的个数，真正能读的是n-1个。
fgets()函数的返回值是char*：，其返回情况：
读取成功，从(pf)流中读了n-1个字符放到string（字符数组中），函数返回的是string字符串；
读取失败，遇到错误或遇到文件结束的条件函数返回的是NULL。
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读文件，读一行
char buf[1000] = { 0 };
//从文件中读数据读的是字符串，然后存起来就用数组存！
fgets(buf, 1000, pf);
//读的数据放到buf中数组中；fgets()第三个参数是说明从pf流中读
printf("%s", buf);
fgets(buf, 1000, pf);
printf("%s", buf);
fclose(pf);
pf = NULL;
return 0;
}//屏幕上：
//hello world
//hehe
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读文件，读一行
char buf[1000] = { 0 };
fgets(buf, 3, pf);
printf("%s", buf);
fclose(pf);
pf = NULL;
return 0;
}//屏幕上：
//he
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读文件，读一行
char buf[1000] = { 0 };
fgets(buf, 3, pf);
printf("%s", buf);
fgets(buf, 3, pf);
printf("%s", buf);
fclose(pf);
pf = NULL;
return 0;
}//屏幕上：
//hell由以上所学写一个拷贝文件的功能：
功能：实现一个代码将data.txt拷贝一份生成data2.txt。
思路：打开data.txt文件——读取内容——打开data2.txt文件——写入内容
实现：
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pr = fopen("data.txt", "r");//以读的形式打开
if (pr == NULL)
{
printf("open for reading:%s\n", strerror(errno));
return 0;
}
//打开成功，pr指向data.txt文件
FILE* pw = fopen("data2.txt", "w");//以写的形式打开
if (pw == NULL)
{
printf("open for writing:%s\n", strerror(errno));
//打开data2.txt文件失败，则提示报错外应该关闭data.txt文件
fclose(pr);
pr = NULL;
return 0;
}
//两个文件均打开成功
//拷贝文件——一个字符一个字符地读
int ch = 0;
while ((ch = fgetc(pr)) != EOF)//成功读取一个字符
{
fputc(ch, pw);//把ch值写入pw中
}
//关闭文件：
fclose(pr);
pr = NULL;
fclose(pw);
pw = NULL;
return 0;
}注意：
以"w"方式打开文件：如果文件原本不存在则不会打开失败，它会再创建一个新的文件；若文件不允许访问则会打开失败，还有其他原因如断电，硬件问题导致打开文件失败。
结果：就会在data.txt文件路径下出现data2.txt文件并拷贝成功。
4.3 结构体的fprintf()写与fscanf()读
fprintf()函数和fscanf()函数的使用：
1、写格式化数据：
fprintf()函数：
int fprintf( FILE *stream, const char *format [, argument ]...);
与printf()函数比较：
printf()函数：
int printf( const char *format [, argument]... );
#include <stdio.h>
#include <errno.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
double d;
};
int main()
{
struct Stu s = { "张三",20,95.5f };
//把结构体的内容写到文件中：
FILE* pf = fopen("data.txt", "w");//以写的形式打开文件
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//成功打开文件，写格式化的数据：
//若是printf()函数：
/*printf("%s %d %lf", s.name, s.age, s.d);*/
fprintf(pf,"%s %d %lf", s.name, s.age, s.d);//写到pf流中
fclose(pf);
pf = NULL;
return 0;
}//在data.txt文件中：张三 20 95.500000fprintf()函数适用于所有输出流，则：
#include <stdio.h>
#include <errno.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
double d;
};
int main()
{
struct Stu s = { "张三",20,95.5f };
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写格式化数据
fprintf(stdout, "%s %d %lf", s.name, s.age, s.d);
fclose(pf);
pf = NULL;
return 0;
}//在屏幕上：张三 20 95.5000002、读格式化数据：
fscanf()函数：
int fscanf( FILE *stream, const char *format [, argument ]... );
与scanf()函数比较：
int scanf( const char *format [,argument]... );
#include <stdio.h>
#include <errno.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
double d;
};
int main()
{
struct Stu s = { "张三",20,95.5f };
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读格式化数据：
//fscanf()函数从键盘上读数据放s中：
fscanf(pf, "%s %d %lf", s.name, &(s.age), &(s.d));
//键盘上读到的的统统放到s中了
printf("%s %d %lf",s.name,s.age,s.d);
fclose(pf);
pf = NULL;
return 0;
}//在屏幕上：张三 20 95.500000说明可以按照某种格式把数据书写到文件中，也可以按照某种格式把输入的数据读出来，可以指定格式操作。
注意：
名字是字符串，是地址，则就不需要再取地址，对age、d变量取地址。
4.4 二进制的fwrite()写和fread()读
1、fwrite()函数——二进制的写
size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );
stream——写入的流，指针指向的流（文件结构）
buffer——要被写的数据
size——一个元素的大小，单位是字节
count——元素的个数
把buffer中count个大小为size的数据写到steam流中。
#include <stdio.h>
#include <errno.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
double d;
};
//二进制的写：
int main()
{
struct Stu s[2] = { { "张三",20,95.5f },{ "lisi",16,66.5f}};//结构体数组
FILE* pf = fopen("data.txt", "wb");//wb:只写，以二进制写的方式打开文件
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//按照二进制的方式写文件
fwrite(s, sizeof(struct Stu), 2, pf);
//要从&s的位置开始写2组大小为sizeof(struct Stu)的数据到pf流中
//fwrite(&s, sizeof(struct Stu), 2, pf);也对
fclose(pf);
pf = NULL;
return 0;
}
运行结果：在data.txt文件中：张三 郬@lisi 燩@
这是二进制的信息。
文本信息以二进制形式写入后的数据还和文本信息一样。
乱码——因为写入的是二进制信息（以二进制的方式写进去）若用记事本直接打开，记事本是以文本的格式来解析文件的内容，则解析出的就是乱码。
s是数组名，可以不进行&，s是数组名本来就是地址，但是&s也不会出问题，最好不写&。
2、fread()函数——二进制的读
size_t fread( void *buffer, size_t size, size_t count, FILE *stream );
从stream流中读count个大小为size的数据放到buffer中。
fread()函数返回的是实际读到的完整的元素的个数。若让一次读5个元素，它真的读到5个元素了它就会返回5，但是如果它只读到3个则就会返回3。
即如果发现fread()函数的返回值比count小则说明是最后一次读取，因为这次没读够下次就读不到数据了。如果发现fread()函数的返回值与count相等，说明这一次读取后至少还要读取一次，直达发现fread()函数的返回值小于count。
#include <stdio.h>
#include <errno.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
double d;
};
//二进制的读：
int main()
{
struct Stu s[2] = { 0 };
FILE* pf = fopen("data.txt", "rb");//wb:只读，以二进制读的方式打开文件
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//按照二进制的方式读文件
fread(s, sizeof(struct Stu), 2, pf);
printf("%s %d %lf\n", s[0].name, s[0].age, s[0].d);//打印第一个成员的信息
printf("%s %d %lf\n", s[1].name, s[1].age, s[1].d);
fclose(pf);
pf = NULL;
return 0;
}//在屏幕上：
//张三 20 95.500000
//lisi 16 66.500000
发现以二进制的形式写进去，以二进制的方式拿出来，虽然肉眼看不到但是fread()函数能看到。
注意：
stdout是标准输出，相当于屏幕，只能写不能读。
stdin是标准输入，只能读不能写。
学习sscanf()函数和sprintf()函数：
sprintf()函数：
int sprintf( char *buffer, const char *format [, argument] ... );
把一个结构体的数据直接转化为字符串了。
#include <stdio.h>
struct Stu
{
char name[20];
int age;
double d;
};
int main()
{
char buf[100] = { 0 };
struct Stu s = {"张三",20,95.5f};
sprintf(buf, "%s %d %lf\n", s.name, s.age, s.d);
printf("%s\n", buf);
return 0;
}//在屏幕上：张三 20 95.500000sscanf()函数：
int sscanf( const char *buffer, const char *format [, argument ] ... );
从buffer（字符串）中按照某种格式提取结构体数据。
#include <stdio.h>
struct Stu
{
char name[20];
int age;
double d;
};
int main()
{
char buf[100] = { 0 };
struct Stu s = { "张三",20,95.5f };
struct Stu tmp = { 0 };
sprintf(buf, "%s %d %lf", s.name, s.age, s.d);
printf("%s\n", buf);
//此时从buffer（字符串）中按照某种格式还原结构体数据：
sscanf(buf, "%s %d %lf", tmp.name, &(tmp.age), &(tmp.d));//把读的数据还原到tmp中
//从buf字符串中按照"%s %d %lf"这种格式提取结构体数据放到tmp中
printf("%s %d %lf\n", tmp.name, tmp.age, tmp.d);
return 0;
}//在屏幕上：
//张三 20 95.500000
//张三 20 95.5000004.5 对比一组函数
1、scanf——fscanf——sscanf
2、printf——fprintf——sprintf
scanf从标准输入流(stdin)——键盘上进行格式化输入的函数；
printf向标出输出流(stdout)——屏幕上进行格式化的输出函数。
fscanf可以从标准输入流(stdin)/指定的文件流——键盘/文件上读取格式化的数据；
fprintf把数据按照格式化的方式输出到标准输出流(stdout)/指定的文件流——屏幕/文件。
sscanf可以从一个字符串中提取（转化）出格式化（结构体）数据；
sprintf把一个格式化的数据转换成字符串。
后面格式化数据是指：表格中的 “char *format [, argument] ...”
fprintf()函数是吧后面格式化的数据写到流中；
sprintf()函数是把后面格式化的的数据放到一个字符串中——把格式化的数据直接转化为字符串；
5. 文件的随机读写
文件刚打开没有进行读写时，文件指针指向该文件的起始位置，即如这里文件指针指向a，每读一个字符，文件指针依次向后偏移一个字符，文件指针在不断变化。
5.1 fseek()函数
函数功能：根据文件指针的位置和偏移量来定位文件指针。
int fseek ( FILE * stream, long int offset, int origin );
在stream流中（指哪个文件）以文件指针从文件起始位置origin向前或向后进行offset个偏移量。
起始位置origin的3个选项：
1、fseek()函数读文件：
第1种读法：以SEEK_CUR（文件指针当前的位置）的写法读取文件：
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
//为了读而打开文件,文件打开成功会返回一个FILE*的指针，所以：
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
//如果打开失败，pf则为空指针，打印错误：
printf("%s\n", strerror(errno));
return 0;
}
//打开文件成功
//读文件，一个一个字符地读，从pf流中读取字符，返回的字符放到ch中
int ch = fgetc(pf);
printf("%c\n", ch);//a
//这是一次读取，若读取成功则此时文件指针指向b：（再读一次指向c，再读一次指向d……）
ch = fgetc(pf);
printf("%c\n", ch);//b，此时pf指向c
//ch = fgetc(pf);
//printf("%c\n", ch);//c
//若此时想要pf指向f，则定位文件指针,向后偏移量是3，若向前偏移则偏移量是是负数，偏移-1指向b，偏移-2指向a
//定位文件指针
fseek(pf, 3, SEEK_CUR);//在pf流中从当前文件指针位置SEEK_CUR向后偏移3个偏移量
ch = fgetc(pf);
printf("%c\n", ch);//f
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}第2种读法：以SEEK_SET（文件指针起始位置）的写法读取文件：
不管文件指针当前在哪里都可以从文件起始位置算偏移，比如d位置：从起始位置a到d偏移量是3，如e位置，从起始位置到a到e偏移量是4，则找到f位置就是偏移5：
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
//若此时想要pf指向f，则定位文件指针
//定位文件指针
fseek(pf, 5, SEEK_SET);//在pf流中从文件指针起始位置SEEK_SET向后偏移5个偏移量
ch = fgetc(pf);
printf("%c\n", ch);//f
fclose(pf);
pf = NULL;
return 0;
}第3种读法：以SEEK_END（文件指针起始位置）的写法读取文件：
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
//若此时想要pf指向f，则定位文件指针
//定位文件指针
fseek(pf, -1, SEEK_END);//在pf流中从文件末尾位置SEEK_END向前偏移-1个偏移量
ch = fgetc(pf);
printf("%c\n", ch);//f
fclose(pf);
pf = NULL;
return 0;
}1、fseek()函数写文件：
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
//为了写而打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//写文件——用fputc()函数把a—z的字符写入流中
int ch = 0;
for (ch = 'a'; ch <= 'z'; ch++)
{
fputc(ch, pf);
}
//定位文件指针
fseek(pf, -1, SEEK_END);//从文件末尾位置向前定位1个
fputc('#', pf);//把z改成#了
fseek(pf, -2, SEEK_END);
fputc('#', pf);//把y改成#了
fclose(pf);
pf = NULL;
return 0;
}//在test.txt文件中：abcdefghijklmnopqrstuvwx##即通过fseek()函数可以让文件指针指向文件里的任意位置，然后进行操作，但是使用这个函数的前提是清楚文件的内容。
5.2 ftell()函数
函数功能：返回文件指针相对于起始位置的偏移量。
long ftell( FILE *stream );
即告诉流中文件指针的位置：
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读文件
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
//此时告诉我们一下流中文件指针的位置！ret来接收
int ret = ftell(pf);
printf("%d\n", ret);//2
fclose(pf);
pf = NULL;
return 0;
}
5.3 rewind()函数
函数功能：让文件指针的位置回到文件的起始位置。
void rewind( FILE *stream );
rewind()函数的功能实际也可以通过fseek()函数的效果实现——从文件的起始位置开始偏移0个偏移量。用rewind()函数相对更简单一些。
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
//读文件
int ch = fgetc(pf);
printf("%c\n", ch);//a
ch = fgetc(pf);
printf("%c\n", ch);//b
//此时告诉我们一下流中文件指针的位置！ret来接收
int ret = ftell(pf);
printf("%d\n", ret);//2
rewind(pf);//让文件指针回到文件的起始位置
//就等价于fseek(pf,0,SEEK_SET);//从SEEK_SET起始位置开始偏移0个偏移量
//fseek(pf, 0, SEEK_SET);
ret = ftell(pf);//则此时偏移量就是0
printf("%d\n", ret);//0
fclose(pf);
pf = NULL;
return 0;
}
6. 文本文件和二进制文件
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
二进制文件：
数据在内存中以二进制的形式存储，如果不加转换的输出到外存（输出或写到文件中），就是二进制文件。二进制读写进去的文件就是二进制文件，二进制文件中放的是不可以看懂的文件信息，二进制文件用文本编辑器是看不懂的。
文本文件：
如果要求在外存或文件中以ASCII码的形式存储，则需要在存储前进行转换。以ASCII字符的形式存储的文件就是文本文件。按照字符形式存的文件就是文本文件，文本文件放的是可以看懂的、用文本编辑器可以解析的文件信息。
对文本文件和二进制文件具体化理解：
一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储；
数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式（就是以字符形式）输出（存储）到磁盘（就是输出到硬盘或写到文件中）——文本文件型存储，这种存储方式磁盘中占用5个字节（每个字符一个字节）；
解释补充：如10000中1用字符1表示，0用字符0表示，即字符1，字符0，字符0，字符0，字符0。字符1的ASCII码值是49，再把49存进去；字符0的ASCII码是48，再把48存进去……按照这样的形式存进去，把表示10000这个数字的每一位的字符以ASCII码值的形式存到文件中——这种存储形式是文本文件形式存储。
而整数10000按二进制形式（10000的二进制序列）不加任何转换直接输出（写到文件中）——二进制文件，则在磁盘上只占4个字节（VS2019测试）。
测试代码：
#include <stdio.h>
int main()
{
int a = 10000;
FILE* pf = fopen("test.txt", "wb");//以wb只写的方式打开一个二进制文件，fopen()的返回值放到pf中
fwrite(&a,4,1,pf);//二进制的写
//把a中的数字10000写到pf指向的流中，一次写4个字节（一个整型就是4个字节），写1次（只有这1个整型）,
//即是10000以二进制的形式写到pf所指向的文件中
fclose(pf);
pf = NULL;
return 0;
}//以二进制编辑器打开test.txt文件：10 27 00 00
解释：
十进制的10000对应的二进制：
0000 0000 0000 0000 0010 0111 0001 0000
转换为十六进制：
0 0 0 0 2 7 1 0
写成十六进制形式：
0x 00 00 27 10
发现就是直接把二进制数据不加任何转换放到文件中了。（在内存中是小端存放的，直接把小端描述的信息：10 27 00 00放到文件中了）
7. 文件读取结束的判定
读文件：
fetc——一个字符一个字符的读；
fgtec——一行一行的读字符；（文本行方式，读的是字符串）
fread——以二进制方式的读数据。
总有把文件读完的时候，那么什么情况下文件算是读取结束了呢？
7.1 被错误使用的feof
牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。
而是应用于当文件读取结束的时候（是已经知道文件读取结束了），用来判断是读取失败结束，还是遇到文件结尾结束——即feof()函数是判断文件读取结束的原因。
文件读取结束的判定：（文件无非是文本文件或是二进制文件）
1、文本文件的读取是否结束，判断返回值是否为 EOF （用 fgetc()函数读取 ——读取正常返回的是所读字符的ASCII码值，读取失败返回的是EOF），或者 NULL （ 用fgets()函数读取—— 读取正常返回的是所读字符串存储到空间中的起始地址，读取失败返回的是NULL）
例如：
fgetc() 判断返回值是否为 EOF ，如果是EOF则读取结束，否则文件读取未结束。fgetc() 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
fgets()判断返回值是否为 NULL ，如果是NULL则读取结束，否则文件读取未结束。
2、二进制文件的读取是否结束，判断返回值是否小于实际要读的个数。
例如：
用fread()函数的返回值判断是否小于实际要读的个数。
正确的使用：
⑴文本文件的例子：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int c;//注意是int，不是char，要处理EOF
FILE* fp = fopen("test.txt", "r");//以读的形式打开文件
if (!fp)
{
//fp为空指针：
perror("FILE opening failed");
return EXIT_FAILURE;
}
//fgetc当读取失败的时候或者遇到文件结束的时候，都会返回EOF
while ((c = fgetc(fp)) != EOF)//标准C I/O读取文件循环
{
putchar(c);
}//停下来
//判断是什么原因结束的
if (ferror(fp))//把fp传到ferror中
{
puts("I/O error when reading");
}
//若不是I/O错误是不是其他错误？
else if (feof(fp))
{
puts("End of file reached successfully");//遇到文件末尾结束
}
fciose(fp);
fp = NULL;
return 0;
}
ferror()函数如果返回为真，说明是文件读取失败了，读取过程中出现问题或错误——I/O错误。
feof()函数的返回值为真，说明是正常读取遇到文件结束（末尾）而结束；为假则是因为其他错误。
⑵二进制文件的例子：
#include <stdio.h>
enum { SIZE = 5 };
int main(void)
{
double a[SIZE] = { 1.0,2.0,3.0,4.0,5.0 };
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);
}//运行结果：
//Array read successfully, contents:
//1.000000 2.000000 3.000000 4.000000 5.000000
puts()函数:
Write a string to stdout——在屏幕上输出字符串。
int puts( const char *string );
8. 文件缓冲区
ANSIC 标准（C语言标准）采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘（硬盘）输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘（硬盘）上。如果从磁盘向计算机（内存）读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C的编译系统决定的。
逻辑理解：
如果要把代码中的程序数据区如创建的变量等这些数据放到硬盘上，也就是放到文件中，不是直接放到文件中，而是先放到内存中的一个输出缓冲区中，输出缓冲区放满了再把数据写到硬盘上。
输入也一样：
如果要从硬盘上读数据，不是把数据写到程序中，而是先把数据放到输入缓冲区，输入缓冲区放满，才把数据放到程序数据区。
为什么会存在缓冲区？
写出来的C语言代码是用户程序，若用户程序要在屏幕上打印信息，则调用printf()函数，实际上printf()函数内部调用了系统调用这样的函数如api()函数(系统调用是操作系统提供的操作接口，api是接口，理解为函数)让操作系统在屏幕上打印信息。
操作系统如Windows系统会跑一堆的程序，会为很多程序服务。
给printf一个缓冲区，把要打印的数据放在缓冲区，缓冲区放满后操作系统打印一次；也可以不放满缓冲区交给操作系统打印——刷新缓冲区，也就是强制操作系统打印。通常写printf()函数常带\n就有刷新缓冲区的作用。
缓冲区有很多维护方式：
把缓冲区放满，放满之后写一次就是一种常规的方式。
代码演示效果：
#include <stdio.h>
#include <windows.h>
//VS2019 WIN10环境测试
int main()
{
FILE* pf = fopen("test.txt", "w");
fputs("abcdef", pf);//先将代码放在输出缓冲区,把abcdef写到pf所指向的文件中
//不会立刻写到文件中，先放到输出缓冲区中
printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
Sleep(10000);//10000毫秒，这10秒中test.txt文件中没有abcdef
printf("刷新缓冲区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
//注：fflush 在高版本的VS上不能使用了
printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
Sleep(10000);//刷新缓冲区后这10秒内test.txt文件中就有abcdef了
fclose(pf);
//注：fclose在关闭文件的时候，也会刷新缓冲区,所以是睡眠10秒后再关闭文件，让在10秒内
//打开文件看，文件中已经有信息了——abcdef，关闭文件是不会影响前面看到的内容的。
pf = NULL;
return 0;
}发现：
写文件的时候不一定直接就把数据写到文件中去，而首先是写到缓冲区中，当刷新缓冲区或缓冲区放满的时候才放到硬盘中。
在Linux环境中看缓冲区的效果：
#include <stdio.h>
int main()
{
while (1)
{
printf("hehe");
sleep(10000);
}
return 0;
}
代码没有立即输出，每一次写一个hehe，这个hehe都写在缓冲区中，此时数据并没有把缓冲区写满，一秒写一个hehe，一直往缓冲区中放，直到把缓冲区放满，这时会出现一屏幕hehe（把缓冲区中所放的数据都打印出来）。
对比：
#include <stdio.h>
int main()
{
while (1)
{
printf("hehe");
sleep(10000);
}
return 0;
}
这里则会一秒出现一次hehe。
说明：
在打印内容里加\n，表示放到缓冲区中的数据这次就要打印出来，是以一行缓冲，放一行后换行就立刻刷新一次——这种效果在Windows环境中是演示不出来的，因为支持的缓冲区效果不同实现的效果就不同。
注意：
printf()函数是不刷新缓冲区的，加\n会刷新缓冲区，行缓冲的时候会刷新缓冲区。
独立的函数fflush()函数会刷新缓冲区。
fclose()函数，在关闭文件的时候也会先刷新缓冲区，让缓冲区中的数据先放到文件中然后再把文件关闭掉。
把数据放到缓冲区中这不是刷新缓冲区，所谓的刷新缓冲区是把缓冲区中的数据放到硬盘上、放到文件中。
这里可以得出一个结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题。
fputs()函数：
Write a string to a stream——写一个字符串到流中。
int fputs( const char *string, FILE *stream );
fflush()函数：
Flushes a stream——冲洗流中的信息，常用于处理磁盘文件，清空输入缓冲区。
int fflush( FILE *stream );
寄个知识小卡片：
整数的ASCII表示形式——整数的每一位都按其对应的字符表示，然后存的是每一位对应字符的数字的二进制序列。
sizeof()括号中放类型的时候，括号不能省略，但若是放表达式或值则可以省略。
若a是数组名，*a就是第一个元素，sizeof(*a)就是数组第一个元素大小。
- sizeof(*a) = sizeof(a[0])
- sizeof(*a) = sizeof *a ≠ sizeof(a)