文件操作的这些知识你学到了吗？画图+文字超详细讲解

admin管理员组

文章数量:1592975

文件操作

文章目录

• 文件操作
• • 为什么使用文件
  • 什么是文件
  • • 程序文件
    • 数据文件
    • 文件名
  • 文件的打开和关闭
  • • 文件指针
    • 文件的打开和关闭
  • 文件的顺序读写
  • • 字符输出函数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<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, s.f);
    //sprintf把一个格式化的数据转化成字符串
    printf("%s\n", buff);

    //从buff字符串中还原出结构体数据
    sscanf(buff, "%s %d %f", s.arr, &(s.age), &(s.f));//从一个字符串中读取一个格式化的数据
    printf("%s %d %f\n", s.arr, s.age, s.f);
    return 0;
}

---

二进制输出函数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 <stdio.h>
enum { SIZE = 5 };
int main(void)
{
  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);
}

我们看其中的这块代码：

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 <stdio.h>
#include <windows.h>
//VS2013 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;
}

​ fputs(“abcdef”, pf);这个代码实际上先将代码放在输出缓冲区，然后睡眠10秒我们查看文件发现果然没有内容。

fflush(pf);刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘），在睡眠10秒时，我们查看文件发现文件里有了内容

注意：

fclose在关闭文件的时候，也会刷新缓冲区，所以我们fclose不能写在第一个sleep的前面，需要写在最后面才能完成测试。

本文标签： 画图文字操作文件知识