超详细讲解C语言文件操作！！
Posted 牵猫散步的明
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了超详细讲解C语言文件操作！！相关的知识，希望对你有一定的参考价值。
超详细讲解C语言文件操作！！
什么是文件
磁盘上的文件是文件。但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
1、程序文件
包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
2、数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，
或者输出内容的文件。
之前我们处理数据的输入输出大都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上；但实际上，有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
那我们为什么要使用文件呢？举个例子，假入我们实现了一个通讯录的代码，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。
文件名
一个文件要有一个唯一的文件标识，以便用户识别和引用。文件名包含3部分：文件路径+文件名主干+文件后缀
例如： c:\\code\\test.txt
为了方便起见，文件标识常被称为文件名。
文件的打开和关闭
文件指针
一个指针变量指向一个文件，这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作。
缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统
声明的，取名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；
需要提及的是，不同的编译器FILE类型包含的内容不完全相同，但是大同小异，因此读者可以灵活变通，不必拘泥于某一种编译器的文件类型声明。
每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，而一般我们就是通过一个文件指针FILE来维护这个FILE结构的变量。
下面我们创建一个FILE指针的变量：
FILE* pf;//文件指针变量
定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。
文件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。而关闭文件与否非常重要，在后面我会着重讲述这一个点。在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。
一般，ANSIC 规定，打开文件我们使用的是fopen函数，关闭文件使用的是fclose文件，具体的文件函数我会单独写一篇博客进行介绍，这边读者们可以了解相关的函数参数，大致了解即可。
//打开文件
FILE * fopen ( const char * filename, const char * mode );
//关闭文件
int fclose ( FILE * stream )；
而打开文件的方式也有许多种。
| 文件使用方式 | 含义 | 如果指定文件不存在 |
|---|---|---|
| “r”（只读） | 为了输入数据，打开一个已经存在的 文本文件 | 出错 |
| “w”（只写） | 为了输出数据，打开一个文本文件 | 建立一个新的文件 |
| “a”（追加） | 向文本文件尾添加数据 | 建立一个新的文件 |
| “rb”（只读） | 为了输入数据，打开一个二进制文件 | 出错 |
| “rb”（只读） | 为了输入数据，打开一个二进制文件 | 出错 |
| “wb”（只写） | 为了输出数据，打开一个二进制文件 | 建立一个新的文件 |
| “ab”（追加） | 向一个二进制文件尾添加数据 | 出错 |
| “r+”（读写） | 为了读和写，打开一个文本文件 | 出错 |
| “w+”（读写） | 为了读和写，建议一个新的文件 | 建立一个新的文件 |
| “a+”（读写） | 打开一个文件，在文件尾进行读写 | 建立一个新的文件 |
| “rb+”（读写） | 为了读和写打开一个二进制文件 | 出错 |
| “wb+”（读写） | 为了读和写，新建一个新的二进制文件 | 建立一个新的文件 |
| “ab+”（读写） | 打开一个二进制文件，在文件尾进行读和写 | 建立一个新的文件 |
下面进行代码的演示：
/* fopen fclose example */
#include <stdio.h>
int main ()
FILE * pFile;
//打开文件
pFile = fopen ("myfile.txt","w");
//文件操作
if (pFile!=NULL)
fputs ("fopen example",pFile);
//关闭文件
fclose (pFile);
return 0;
需要注意的是，打开的文件一定要存在，且代码中打开文件的路径方式是因为文件本身就处在我们创建的C语言程序文件夹中，且注意的是txt是文件的后缀名而非名称的一部分。
文件的顺序读写
在进行继续讲解时，我们首先要明白，文件指针中的 FILE * stream中的stream是什么。stream即为流，而流分为很多种，上述图中的所有输入\\输出流即是指所有类型都可以进行输入输出，而文件指针对应的是文件流，即更改或读取等文件的数据。
流按方向分为:输入流和输出流。从文件获取数据的流称为输入流，向文件输出数据称为输出流。
流按数据形式分为:文本流和二进制流。文本流是 ASCII 码字符序列，而二进制流是字节序列。
流是一种抽象的概念，负责在数据的产生者和数据的使用者之间建立联系，并管理数据的流动。
任何一个C语言程序运行时都会默认打开三个流：
stdin——标准输入（键盘）
stdout——标准输出（屏幕）
stdenr——标准错误（屏幕）
标准流属于流的一种。
具体的各函数讲解我会新写一篇博客进行，这边便不多赘述。
文件的随机读写
fseek
设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 origin 位置查找的字节数。
stream – 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
offset – 这是相对 whence 的偏移量，以字节为单位。
origin – 这是表示开始添加偏移 offset 的位置。它一般指定为下列常量之一。
下面的实例演示了 fseek函数的用法：
#include <stdio.h>
int main ()
FILE *fp;
fp = fopen("file.txt","w+");
fputs("This is runoob.com", fp);
fseek( fp, 7, SEEK_SET );
fputs(" C Programming Langauge", fp);
fclose(fp);
return(0);
编译并运行上面的程序，这将创建文件 file.txt，它的内容如下。最初程序创建文件和写入 This is runoob.com，但是之后我们在第七个位置重置了写指针，并使用 puts() 语句来重写文件，内容如下：
This is C Programming Langauge
ftell
返回给定流 stream 的当前文件位置。（返回文件指针相对于起始位置的偏移量）
stream – 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
该函数返回位置标识符的当前值。如果发生错误，则返回 -1L，全局变量 errno 被设置为一个正值。
下面的实例演示了 ftell函数的用法:
#include <stdio.h>
int main ()
FILE *fp;
int len;
fp = fopen("file.txt", "r");
if( fp == NULL )
perror ("打开文件错误");
return(-1);
fseek(fp, 0, SEEK_END);
len = ftell(fp);
fclose(fp);
printf("file.txt 的总大小 = %d 字节\\n", len);
return(0);
假设我们已经有了一个文本 file.txt，它的内容如下：
This is runoob.com
译并运行上面的程序，如果文件内容如上所示，这将产生以下结果，否则会根据文件内容给出不同的结果：file.txt 的总大小 = 19 字节。
rewind
设置文件位置为给定流 stream 的文件的开头（让文件指针的位置回到文件的起始位置）
stream – 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
该函数不返回任何值。
下面演示该函数用法。
/* rewind example */
#include <stdio.h>
int main ()
int n;
FILE * pFile;
char buffer [27];
pFile = fopen ("myfile.txt","w+");
for ( n='A' ; n<='Z' ; n++)
fputc ( n, pFile);
rewind (pFile);
fread (buffer,1,26,pFile);
fclose (pFile);
buffer[26]='\\0';
puts (buffer);
return 0;
文本文件和二进制文件
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2013测试）。
而对于二进制输出的文本文档，我们仍然可以用编译器进行查看。
注意小端存储以及数据以16进制显现。
文件读取结束的判定
在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。
而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束
1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
例如：
fgetc 判断是否为 EOF .
fgets 判断返回值是否为 NULL .
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
fread判断返回值是否小于实际要读的个数。
文件缓冲区
由于CPU 与 I/O 设备间速度不匹配。为了缓和 CPU 与 I/O 设备之间速度不匹配矛盾。文件缓冲区是用以暂时存放读写期间的文件数据而在内存区预留的一定空间。使用文件缓冲区可减少读取硬盘的次数。
ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。
因此我们常说，打开文件对文件进行操作后要关闭文件，是因为fclose关闭文件操作执行前会自动进行缓冲区刷新操作。
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题。
那么，今天的C语言文件操作的使用详解的相关内容我就讲述完啦，因为个人能力有限，文章难免会出现纰漏，届时有错误可以私信发给我以及时更正，谢谢大家！
文件操作的这些知识你学到了吗？画图+文字超详细讲解
文件操作
文章目录
为什么使用文件
我们在进行程序设计中，数据往往是非常重要的，我们之前的知识中，我们程序运行起来数据会出现，而当我们关闭了程序之后，数据就没有了，比如我们写了一个通讯录程序，当通讯录运行起来的时候，我们可以给通讯录增加、删除、修改数据，此时的数据是存放在内存中，当程序退出的时候，这些数据就不存在了，等我们下次使用通讯录时，又需要重新录入数据，我们这时想把通讯录中的数据保存下来，只有在我们删除时，这些数据才会不见，这就涉及到了数据持久化的问题，把数据存放在磁盘文件、存放到数据库可以做到数据的持久化，而使用文件我们就将数据存放到磁盘中去了，做到了数据的持久化。
什么是文件
在程序设计中，我们一般有两种文件：程序文件、数据文件(从文件的功能进行分类)
我们打开我们创建的代码路径，我们创建一个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<stdio.h>
int main()
{
FILE* pf = fopen("test.dat", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
文件的顺序读写
顺序读写函数：
| 功能 | 函数名 | 适用于 |
|---|---|---|
| 字符输入函数 | 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<stdio.h>
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s={"hello",20,5.5f};
char buff[100]={0};
sprintf(buff,"%s %d %f",s.arr,s.age,s.f);
//sprintf把一个格式化的数据转化成字符串
printf("%s",buff);
return 0;
}
scanf、fscanf、sscanf的区别
scanf和fscanf我们都已经了解，所以这里主要讲sscanf
scanf是针对标准输入的格式化的输入语句，即stdin流
fscanf是针对所有输入流的格式化的输入语句 ，比如stdin流、文件流
sscanf
从一个字符串中读取一个格式化的数据
- 函数原型以及参数解释
那么它如何使用呢？
#include<stdio.h>
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s = { "hello",20,5.5f };
char buff[100] = { 0 };
sprintf(buff, "%s %d %f", s.arr, s.age搞定C语言指针，指针超详细讲解，及指针面试题