文件操作的这些知识你学到了吗？画图+文字超详细讲解
文件操作
文章目录
- 文件操作
-
- 为什么使用文件
- 什么是文件
-
- 程序文件
- 数据文件
- 文件名
- 文件的打开和关闭
-
- 文件指针
- 文件的打开和关闭
- 文件的顺序读写
-
- 字符输出函数fputc
- 字符输入函数fgetc
- 文本行输出函数fputs
- 文本行输入函数fgets
- 格式化输出函数fprintf
- 格式化输入函数fscanf
- printf、fprintf、sprintf的区别
- scanf、fscanf、sscanf的区别
- 二进制输出函数fwrite
- 二进制输入函数fread
- 文件的随机读写
-
- fseek
- ftell
- rewind
- 文本文件和二进制文件
- 文件读取结束的判定
-
- 被错误使用的feof
- 文本文件的例子
- 二进制文件的例子
- 文件缓冲区
为什么使用文件
我们在进行程序设计中，数据往往是非常重要的，我们之前的知识中，我们程序运行起来数据会出现，而当我们关闭了程序之后，数据就没有了，比如我们写了一个通讯录程序，当通讯录运行起来的时候，我们可以给通讯录增加、删除、修改数据，此时的数据是存放在内存中，当程序退出的时候，这些数据就不存在了，等我们下次使用通讯录时，又需要重新录入数据，我们这时想把通讯录中的数据保存下来，只有在我们删除时，这些数据才会不见，这就涉及到了数据持久化的问题，把数据存放在磁盘文件、存放到数据库可以做到数据的持久化，而使用文件我们就将数据存放到磁盘中去了，做到了数据的持久化。
什么是文件
在程序设计中，我们一般有两种文件：程序文件、数据文件(从文件的功能进行分类)
我们打开我们创建的代码路径，我们创建一个test.dat文件：
我们的代码文件称为程序文件，而在我们写程序时，我们需要在test.dat文件中进行读写操作(将文件里的内容读到程序里，或者用程序在这个文件里写一些东西)，这样的文件我们称为数据文件
程序文件
程序文件包括源程序文件(后缀为.c文件)，目标文件(windows环境后缀为.obj)，可执行程序(windows环境下后缀为.exe)，可执行程序是在程序运行起来后才会出现的。.obj文件是在程序编译时产生的文件
.obj文件在代码路径的第二个Debug文件中
.c文件
.exe文件在第一个Debug文件中：
数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件或者输出内容的文件
我们之前在输入输出数据都是在终端，编译器的控制台，我们今天主要讲的是数据文件。
文件名
我们每一个人都有自己的名字，文件当然也有它自己的名字，一个文件具有一个唯一的文件标识，以便用户去识别和打开它。
文件名包括三个部分：文件路径+文件名主干+文件后缀
c:\code\test.txt
test是文件名主干，.txt是文件后缀，前面部分为文件路径
文件的打开和关闭
文件指针
提到文件，我们就不得不谈一下文件指针，每一个被使用的文件都在内存中开辟了一个相对应的文件信息区，这个信息区用来存放文件的相关信息，比如文件名，文件状态以及文件的位置等。这些信息都保存至一个结构体中，该结构体类型是由系统声明的，取名为FILE，而FILE*类型的指针就是指向文件信息区这样类型的结构体的指针。
在vs编译器环境中，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类型的结构体变量的指针，通过这样的指针来指向某个文件的文件信息区(结构体变量)，通过文件信息区中的信息就能访问到该文件。
文件的打开和关闭
我们在读写文件前必须先打开文件，在使用结束后应该关闭文件。
- fopen函数的原型以及参数解释
返回值：
当成功打开文件时会返回指向文件的指针，若没有打开成功则返回一个NULL指针。
文件的打开方式：
文件的打开方式表：
| 文件使用方式 | 含义 | 如果指定文件不存在 |
|---|---|---|
| “r”（只读） | 为了输入数据，打开一个已经存在的文本文件 | 出错 |
| “w”（只写） | 为了输出数据，打开一个文本文件 | 建立一个新的文件 |
| “a”（追加） | 向文本文件尾添加数据 | 建立一个新的文件 |
| “rb”（只读） | 为了输入数据，打开一个二进制文件 | 出错 |
| “wb”（只写） | 为了输出数据，打开一个二进制文件 | 建立一个新的文件 |
| “ab”（追加） | “ab”（追加） 向一个二进制文件尾添加数据 | 出错 |
| “r+”（读写） | 为了读和写，打开一个文本文件 | 出错 |
| “w+”（读写） | 为了读和写，建议一个新的文件 | 建立一个新的文件 |
| “a+”（读写） | 打开一个文件，在文件尾进行读写 | 建立一个新的文件 |
| “rb+”（读写） | 为了读和写打开一个二进制文件 | 出错 |
| “wb+”（读写） | 为了读和写，新建一个新的二进制文件 | 建立一个新的文件 |
| “ab+”（读写) | 打开一个二进制文件，在文件尾进行读和写 | 建立一个新的文件 |
我们开始写代码打开文件：
int main()
{
FILE* pf = fopen("test.dat", "w");//相对路径
FILE* pf = fopen("D:\\vs-bit-code\\test-7-20\\test-7-20\\test.dat",'w');//绝对路径
return 0;
}
注意：
文件名可以写相对路径也可以写绝对路径，以绝对路径打开时，要注意转义字符
打开文件返回的是一个FILE*类型的指针，所以我们需要用FILE*的类型的指针来接受它。而返回值是当打开成功时才返回指向文件的指针，打开失败则返回NULL指针。
所以我们还要进行判断：
int main()
{
FILE* pf = fopen("test.dat", "w");
if(pf==NULL)
{
perror("fopen");
return 1;
}
return 0;
}
当打开文件成功时，我们就要进行写文件，写文件完成之后，我们需要关闭文件
文件的关闭：
返回值：
fclose函数在成功关闭文件后，会返回0，否则返回EOF(-1)。它的参数指向FILE结构体变量
int main()
{
FILE* pf = fopen("test.dat", "w");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//写文件
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
以读的方式打开文件与关闭文件：
#include文件的顺序读写
顺序读写函数：
| 功能 | 函数名 | 适用于 |
|---|---|---|
| 字符输入函数 | fgetc | 所有输入流 |
| 字符输出函数 | fputc | 所有输出流 |
| 文本行输入函数 | fgets | 所有输入流 |
| 文本行输出函数 | fputs | 所有输出流 |
| 格式化输入函数 | fscanf | 所有输入流 |
| 格式化输出函数 | fprintf | 所有输出流 |
| 二进制输入 | fread | 文件 |
| 二进制输出 | fwrite | 文件 |
注意：
我们在写文件时，将硬盘中文件的数据写到内存中去叫输出或者写入，在读文件时，将内存中的数据保存到硬盘中去叫输入或者读取。
字符输出函数fputc
写一个字符到一个流，或者到标准输出
int main()
{
FILE*pf=fopen("test.dat","w");//以w打开，若存在文件，则会销毁文件内容
if(pf==NULL)
{
perror("fopen");
return 1;
}
//写文件
fputc('a',pf);
fputc('b',pf);
fputc('c',pf);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
我们打开文件，发现确实写进去了
fputc不一定只能写到文件里面去，还可以写到标准输出流，这里给大家讲一下流的概念：
流是一个高度抽象的概念，我们写一个程序，我们有时想把程序的数据放到屏幕、硬盘、U盘、光盘、网络、软盘等上去，而这些硬件不同，则读写方式就不同，那我们就需要知道不同硬件的不同读写形式，但是这样的成本太高了，要写到不同硬件上去，就要懂各种各样的读写形式，则引入了流，我们只需要将数据写入流，流会将我们的数据写入到不同的外部设备中去。
画图解释流：
C语言程序只要运行起来，就默认打开了3个流：
stdin - 标准输入流 - 键盘
stdout - 标准输出流 - 屏幕
stderr - 标准错误流 - 屏幕
这三个流的类型都是FILE，文件的指针*
当理解了流，我们刚刚打开文件写文件时，就是将数据写到了文件流里面去，了解了这些，我们可以利用fputc函数向屏幕上写字符。
int main()
{
fputc('b',stdout);
fputc('b',stdout);
fputc('b',stdout);
return 0;
}
字符输入函数fgetc
读一个字符从流里面，或者从标准输入流
- 函数的原型以及参数解释
返回值：
读取成功将返回该字符的ASCII码值，读取失败则返回EOF(-1)。
int main()
{
FILE*pf=fopen("test.dat","r");//以r打开
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读文件
int ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
那么我们读到文件末尾会发生什么呢？
我们来做个测试：
int main()
{
FILE*pf=fopen("test.dat","r");//以r打开
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读文件
int ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
ret = fgetc(pf);
printf("%c\n",ret);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
我们调试发现：
读到文件末尾，读取失败了，就会返回EOF(-1)
我们可以在文件流里读取东西，当然我们也可以在标准输入流中读取：
int main()
{
//读文件
int ret = fgetc(stdin);
printf("%c\n", ret);
ret = fgetc(stdin);
printf("%c\n", ret);
ret = fgetc(stdin);
printf("%c\n", ret);
return 0;
}
读一个一个字符是不是太慢了？当然，我们还有一行一行的读写的函数，接下来我们来看：
文本行输出函数fputs
写一个字符串到流
- 函数原型以及参数解释
返回值：
如果输出成功，则返回非负的一个数，输出失败，则返回EOF(-1)。
int main()
{
FILE* pf=fopen("test.dat","w");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//写文件-按照行写文件
fputs("abcdef",pf);
fputs("abcdef",pf);
fputs("abcdef",pf);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
我们发现写进去的字符串都在一行
注意：
如果想要写入文件的每行字符串换行，必须自己在字符串后面加上换行符\n
fputs("abcdef\n",pf);
我们修改后发现确实换行了：
文本行输入函数fgets
得到一个字符串从一个流
- 函数原型以及参数解释
返回值以及参数：
读取成功将返回该字符串，读取失败将返回NULL指针，string参数是存放字符串的数据的位置，n参数是读取字符数的最大个数，最后一个参数为流。
int main()
{
char arr[10]={0};
FILE* pf=fopen("test.dat","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读文件
fgets(arr,4,pf);//最多读n-1个，因为最后一个需要存放\0
printf("%s\n",arr);
fgets(arr,4,pf);
printf("%s\n",arr);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
注意：
在读取时最多能够读取n-1个字符，因为最后一个需要存放\0
你如果不理解的话我们可以调试看一下：
我们发现确实是将\0存放进去了。
格式化输出函数fprintf
输出格式化的数据到流
- 函数原型以及参数解释
和printf函数相比fprintf多了一个参数
，其作用是输出格式化的数据到流。
fprintf的使用：
struct S
{
char arr[10];
int num;
float sc;
};
int main()
{
struct S s={"abcdef",10,5.5f};
//对格式化的数据进行写文件
FILE* pf = fopen("test.dat","w");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//写文件
fprintf(pf,"%s %d %f",s.arr,s.num,s.sc);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
我们可以看到已经将信息写入到文件。
格式化输入函数fscanf
从一个流里读取标准化的数据
- 函数原型以及参数解释
它和scanf的区别也是多了一个流参数
fscanf的使用：
struct S
{
char arr[10];
int num;
float sc;
};
int main()
{
struct S s={0};
//对格式化的数据进行读文件
fopen("test.dat","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读文件
fscanf(pf,"%s %d %f",s.arr,&(s.num),&(s.sc));
//打印
printf("%s %d %f\n",s.arr,s.num,s.sc);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
我们可以看到我们从文件中读取了标准格式化的数据
printf、fprintf、sprintf的区别
printf是针对标准输出的格式化的输出语句，即stdout流
fprintf是针对所有输出流的格式化的输出语句，例如stdout流、文件流
printf与fprintf相信大家都了解了，就不多说了，下面看sprintf：
sprintf
把一个格式化的数据转化成字符串
- 函数原型以及参数解释
那么它是如何使用的呢？我们用一个结构体来解释，这样更加形象：
#include
scanf、fscanf、sscanf的区别
scanf和fscanf我们都已经了解，所以这里主要讲sscanf
scanf是针对标准输入的格式化的输入语句，即stdin流
fscanf是针对所有输入流的格式化的输入语句 ，比如stdin流、文件流
sscanf
从一个字符串中读取一个格式化的数据
- 函数原型以及参数解释
那么它如何使用呢？
#include二进制输出函数fwrite
写数据到一个流
- 函数原型以及参数解释
返回值：
返回的是实际被写入的完整元素的个数，如果发现写入的完整的元素的个数小于指定的元素个数，这就是最后一次读取了
struct S
{
char arr[10];
int num;
float sc;
};
int main()
{
struct S s={"abcde",10,5.5f};
//二进制形式写
FILE* pf=fopen("test.dat","w");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//写文件
fwrite(&s,sizeof(struct S),1,pf);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
以二进制形式写入，所以我们看不懂。
二进制输入函数fread
- 函数原型以及参数解释
返回值：
返回的是实际读取到的完整元素的个数，如果发现读取到的完整的元素的个数小于指定的元素个数，这就是最后一次读取了
struct S
{
char arr[10];
int num;
float sc;
};
int main()
{
struct S s={0};
//二进制形式读
FILE* pf=fopen("test.dat","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读文件
fread(&s,sizeof(struct S),1,pf);
printf("%s %d %f\n",s.arr,s.num,s.sc);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
文件的随机读写
fseek
根据文件指针的位置和偏移量来定位文件指针
- 函数原型以及参数解释
第三个参数的可取值：SEEK_CUR、SEEK_END、SEEK_SET
我们写出下面代码时，再在代码路径下面创建test.txt文件，比如写入abcdef，我们会从文件的开头开始读取字符，每读取文件指针就会+1移动：
int main()
{
FILE* pf = fopen("test.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
//想读完a然后就读d
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
但是如果我们想读完a然后直接就读d，就需要用到fseek函数了
int main()
{
FILE* pf = fopen("test.txt","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读取文件
int ch = fgetc(pf);
printf("%c\n",ch);//a
//调整文件指针
fseek(pf,2,SEEK_CUR);
ch = fgetc(pf);
printf("%c\n",ch);//d
ch = fgetc(pf);
printf("%c\n",ch);//e
//想读完a然后就读d
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
fseek(pf,2,SEEK_CUR);
从当前文件指针的位置开始偏移2个长度，文件指针就指向了d
不妨看一下上面代码的打印结果：
可以看到我们打印了a、d、e。
ftell
得到当前文件指针的位置(计算偏移量)
- 函数原型以及参数解释
我们依然用上一个函数用过的文件进行演示：
int main()
{
FILE* pf = fopen("test.txt","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读取文件
int ch = fgetc(pf);
printf("%c\n",ch);//a
//调整文件指针
fseek(pf,2,SEEK_CUR);
ch = fgetc(pf);
printf("%c\n",ch);//d
ch = fgetc(pf);
printf("%c\n",ch);//e
int ret = ftell(pf);
printf("%d\n",ret);
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
此时的文件指针指向了f，所以文件指针的偏移量应该为5。
由图打印结果，发现我们的偏移量为5。
rewind
让文件指针回到起始位置
- 函数原型以及参数解释
int main()
{
FILE* pf = fopen("test.txt","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读取文件
int ch = fgetc(pf);
//调整文件指针
fseek(pf,2,SEEK_CUR);
ch = fgetc(pf);
printf("%c\n",ch);//d
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
此时经过了fgetc读取文件，再经过调整文件指针，然后再经过fgetc读取文件，我们的文件指针现在指向了e
现在我们将下面代码加入：
rewind(pf);
int main()
{
FILE* pf = fopen("test.txt","r");
if(pf==NULL)
{
perror("fopen");
return 1;
}
//读取文件
int ch = fgetc(pf);
//调整文件指针
fseek(pf,2,SEEK_CUR);
rewind(pf);
ch = fgetc(pf);
printf("%c\n",ch);//d
//关闭文件
fclose(pf);
pf=NULL;
return 0;
}
此时屏幕应该打印什么呢？大家想一想，第13行代码我们将文件指针回到起始位置，然后之后fgetc进行了一次读取文件，所以这里应该打印的是a，到底对不对呢？我们运行一下就知道了：
果然是a。
拥有了这些随机读写函数，让我们的读写更加灵活。下面我们讲解文本文件和二进制文件：
文本文件和二进制文件
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
二进制文件
数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
文本文件
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节。
int main()
{
int a=10000;
FILE *pf = fopen("test.txt","wb");
if(pf=NULL)
{
perror("fopen");
return 1;
}
//写文件
fwrite(&a,sizeof(int),1,pf);//以二进制的形式写到文件中
fclose(pf);
pf=NULL;
return 0;
}
从文件中看我们是看不懂得，因为是以二进制形式存储的，我们可以在vs编译器上以二进制编辑器打开方式看：
而我们10000的十六进制确实是这样的。
文件读取结束的判定
被错误使用的feof
很多人会错误的使用feof，甚至一些资料都用feof来判断文件是否读取结束，这是错误的。feof函数是判断文件读取结束的原因是读取失败还是遇到文件末尾
注意：
在文件读取过程中，不能用feof函数的返回值来判断文件的是否结束。而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件末尾结束。
- 文本文件读取是否结束，判断返回值是否为EOF(fgetc)，或者NULL(fgets)
fgetc 函数在读取结束的时候，会返回EOF
正常读取的时候返回的时读取到的ASCII码值
fgets 函数在读取结束时，会返回NULL
正常读取的时候，返回存放字符串的空间起始地址
- 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数
fread在读取的时候，返回的是实际读取到的完整元素的个数
如果发现读取到的完整的元素的个数小于指定的元素个数，这就是最后一次读取了
文本文件的例子
写代码把test.txt文件拷贝一份，生成test2.txt
//写代码把test.txt文件拷贝一份，生成test2.txt
int main()
{
FILE *pfread = fopen("test.txt","r");
if(pfread == NULL)
{
return 1;
}
FILE *pfwrite = fopen("test2.txt","w");
if(pfwrite == NULL)
{
fclose(pfread);
pfread=NULL;
return 1;
}
//文件打开成功
//读写文件
int ch=0;
//当读取失败的时候或者遇到文件结束的时候，都会返回EOF
while((ch=fgetc(pfread))!=EOF)
{
//写文件
fputc(ch,pfwrite);
}
if(feof(pfread))
{
printf("遇到文件结束标志、文件正常结束\n");
}
else if(ferror(pfread))
{
printf("文件读取失败结束\n");
}
//关闭文件
fclose(pfread);
pfread = NULL;
fclose(pfwrite);
pfwrite = NULL;
return 0;
}
feof函数返回若为真，则是遇到文件结束标志、文件正常结束，ferror函数为真，则是文件读取失败结束。
我们打开后发现拷贝成功了：
二进制文件的例子
#include 我们看其中的这块代码：
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");
}
fread读取数据，返回值放入ret_code变量中，如果该变量等于指定的元素个数，则读取成功了，否则(该变量小于指定的元素个数，不可能大于)如果feof(fp)为真，则是到达了文件末尾，正常结束，否则如果ferror(fp)为真，则是文件读取失败结束。
文件缓冲区
ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序
中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装
满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓
冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根
据C编译系统决定的。
我们来看个例子：
#include 
fputs(“abcdef”, pf);这个代码实际上先将代码放在输出缓冲区，然后睡眠10秒我们查看文件发现果然没有内容。
fflush(pf);刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘），在睡眠10秒时，我们查看文件发现文件里有了内容
注意：
fclose在关闭文件的时候，也会刷新缓冲区，所以我们fclose不能写在第一个sleep的前面，需要写在最后面才能完成测试。