本章重点

1. 为什么使用文件
2. 什么是文件
3. 文件的打开和关闭
4. 文件的顺序读写
5. 文件的随机读写
6. 文本文件和二进制文件
7. 文件读取结束的判定
8. 文件缓冲区

1.为什么使用文件

我们在使用通讯录时需要把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

2.什么是文件

磁盘上的文件是文件。

但是在程序设计中，我们一般谈的文件有两种：
从文件功能的角度来分：程序文件、数据文件

2.1 程序文件

包括：

源程序文件（后缀为.c）
目标文件（windows环境后缀为.obj）
可执行程序（windows环境 后缀为.exe）

2.2 数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，
比如程序运行需要从中读取数据的文件， 或者输出内容的文件

本关讨论的是数据文件。

在以前各关所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上

其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上的文件。

2.3 文件名

一个文件要有一个唯一的文件标识。

文件名包含3部分：文件路径+文件名主干+文件后缀

例如： 'c: \ code \ test.txt ’ 为了方便起见，文件标识常被称为文件名。

3.文件的打开和关闭

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);

打开方式如下：

文件操作全过程代码如下：

int main()
{//打开文件FILE*pf = fopen("test.txt", "w");//这里只写文件名的话就会在工程目录里面创建该文件 //或  .\test.txt    ;    ..\test.txt是上一级目录FILE*pf1 = fopen("c:\\code\\test1.txt", "w");//这里加上路径就会在指定路径里面建立该文件    if (NULL == pf){perror("fopen");return 1;}//写文件//关闭文件fclose(pf);pf = NULL;return 0;
}

4.文件的顺序读写

4.1 字符 输入 输出 函数

文件的写入（字符类型）：

int main()
{//打开文件FILE* pf = fopen("test.txt", "w");//注意！！！//这用的是 "w":只写，所以我们在再次写入数据的时候，之前的数据会被清空，//如果不想让之前的数据被清空，我们可以用 "a"：追加，在文件尾部添加数据if (NULL == pf){perror("fopen");return 1;}//写文件int i = 0;for (i = 0; i < 26; i++){fputc('a'+i, pf);//一个字符一个字符的写}//关闭文件fclose(pf);pf = NULL;return 0;
}

文件的读取（字符类型）：

int main()
{//打开文件FILE* pf = fopen("test.txt", "w");if (NULL == pf){perror("fopen");return 1;}//读文件int ch = 0;while ((ch = fgetc(pf)) != EOF)//fgetc读取失败后会返回EOF{printf("%c ", ch);}//关闭文件fclose(pf);pf = NULL;return 0;
}

4.2 文本行的 输入 输出 函数

文件的写入（文本行）：

int main()
{//打开文件FILE* pf = fopen("test.txt", "w");if (NULL == pf){perror("fopen");return 1;}//写文件-一行一行写fputs("hello\n", pf);//这里需要手动加\n才会在文件里面换行fputs("world\n", pf);//关闭文件fclose(pf);pf = NULL;return 0;
}

文件的读取（文本行）：

int main()
{//打开文件FILE* pf = fopen("test.txt", "r");if (NULL == pf){perror("fopen");return 1;}//读文件-一行一行读char arr[20] = "#########";fgets(arr, 20, pf);//这里虽然写的是20，但只会读前19个，第20个元素里面会放入'\0'printf("%s", arr);fgets(arr, 20, pf);printf("%s", arr);//关闭文件fclose(pf);pf = NULL;return 0;
}

4.3 格式化的 输入 输出 函数

适用于结构体类型的输入输出

文件的写入（格式化）：

struct S
{char name[20];int age;float score;
};int main()
{struct S s = { "zhangsan", 20, 95.5f };//把s中的数据写到文件中FILE*pf = fopen("test.txt", "w");if (NULL == pf){perror("fopen");return 1;}//写文件fprintf(pf, "%s %d %.1f", s.name, s.age, s.score);//和printf用法类似fclose(pf);pf = NULL;return 0;
}

文件的读取（格式化）：

struct S
{char name[20];int age;float score;
};int main()
{struct S s = {0};//把s中的数据写到文件中FILE* pf = fopen("test.txt", "r");if (NULL == pf){perror("fopen");return 1;}//读文件fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));printf("%s %d %f\n", s.name, s.age, s.score);fclose(pf);pf = NULL;return 0;
}

4.4 二进制的 输入 输出 函数

文件的写入（二进制）：

struct S
{char name[20];int age;float score;
};int main()
{struct S s = { "zhangsan", 20, 95.5f };//把s中的数据写到文件中FILE*pf = fopen("test.txt", "wb");//注意这里是wb，写二进制文件if (NULL == pf){perror("fopen");return 1;}//二进制的写文件，用fwritefwrite(&s, sizeof(s), 1, pf);fclose(pf);pf = NULL;return 0;
}

二进制写入的文件一般会在文件里面显示一些乱码，但计算机用二进制可以读取出来

文件的读取（二进制）：

struct S
{char name[20];int age;float score;
};int main()
{struct S s = {0};//把s中的数据写到文件中FILE* pf = fopen("test.txt", "rb");if (NULL == pf){perror("fopen");return 1;}//二进制的读文件fread(&s, sizeof(s), 1, pf);printf("%s %d %f\n", s.name, s.age, s.score);fclose(pf);pf = NULL;return 0;
}

4.5 C语言默认数据流

可以看到这两个函数是所有输入或输出流，所以他们也可以从键盘上读取，也可以显示到屏幕
用法就和scanf与printf一样

但大家有没有发现，为什么在我们操作文件时，有打开文件和关闭文件的操作？而在读取键盘上的东西，和，打印到屏幕上的东西却没有打开键盘之类的操作？

这是因为对任意一个C程序，只要运行起来，就默认打开3个流：
stdin——标准输入流——键盘
stdout——标准输出流——屏幕
stderr——标准输出流——屏幕

如果我们想用fscanf读取键盘上的数，用fprintf打印到屏幕上时，可以这样写：

int main()
{int ch=fgets(stdin);fputs(ch,stdout);return 0;
}

这样就能读取键盘的数，并打印到屏幕上

4.6 对比一组函数：

scanf / fscanf / sscanf
printf / fprintf / sprintf

scanf：按照一定的格式从键盘输入数据
printf：按照一定的格式把数据打印（输出）到屏幕上
//适用于标准输入 / 输出流的格式化的输入，输出语句

fscanf：按照一定的格式从输入流（文件/stdin）输入数据
fprintf：按照一定的格式向输出流（文件/stdout）输出数据
//适用于所有的 输入 / 输出流 的格式化 输入 / 输出语句

sscanf： 从字符串中按照一定的格式读取出格式化的数据
sprintf： 把格式话的数据按照一定格式转换成字符串

可以参照如下代码：

struct s
{char name[10];int age;float score;
};int main()
{char buf[100] = {0};struct s s = { "zhangsan", 20, 95.5f };sprintf(buf, "%s %d %f", s.name, s.age, s.score);//能够把这个结构体的数据，转换成字符串："zhangsan 20 95.5"  也成为序列化printf("%s\n", buf);//以字符串形式打印struct s tmp = { 0 };//能否将buf中的字符串，还原成一个结构体数据呢？sscanf(buf, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));//还原成为结构体   也成为反序列化printf("%s %d %f\n", tmp.name, tmp.age, tmp.score);//以结构的形式打印return 0;
}

5.通讯录(文件储存,管理)

test.c - 测试通讯录
contact.c - 通讯录实现
contact.h - 函数声明

contact.h - 函数声明

#pragma once
#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<stdlib.h>
#define MAX 100
#define NAME_MAX 20
#define SEX_MAX 5
#define ADDR_MAX 30
#define TELE_MAX 30#define DEFAULT_SZ 3
#define INC_SZ 2
typedef struct PeoInfo
{char name[NAME_MAX];int age;char sex[SEX_MAX];char addr[ADDR_MAX];char tele[TELE_MAX];
}PeoInfo;typedef struct Contact
{PeoInfo* data;//指向存放人的信息的空间int sz;//当前已经存放信息个数int capacity;//当前通讯录的最大容量
}Contact;//初始化通讯录
void InitContact(Contact* pc);
//销毁通讯录
void DestroyContact(Contact* pc);
//增加联系人
void ADDContact(Contact* pc);//删除指定联系人
void DelContact(Contact* pc);//显示通讯录中的信息
void ShowContact(const Contact* pc);//查找指定联系人
void SearchContact(const Contact* pc);//修改指定联系人
void ModifyContact(Contact* pc);// 保存通讯录信息到文件中
void SaveContact(Contact* pc);//加载文件信息到通讯录
void LoadContact(Contact* pc);

contact.c - 通讯录实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"contact.h"void InitContact(Contact* pc)
{assert(pc);pc->sz = 0;PeoInfo* ptr = (PeoInfo*)calloc(DEFAULT_SZ,sizeof(PeoInfo));if (ptr == NULL){perror("InitContact::calloc");return;}pc->data =ptr ;pc->capacity = DEFAULT_SZ;//加载文件信息到通讯录LoadContact(pc);}
void DestroyContact(Contact* pc)
{assert(pc);free(pc->data);pc ->data=NULL;pc->capacity = 0;pc->sz = 0;pc = NULL;
}int FindByName(const Contact* pc, char name[])
{assert(pc);int i = 0;for (i = 0; i < pc->sz; i++){if (strcmp(pc->data[i].name, name) == 0){return i;}}return -1;
}void check_capacity(Contact* pc)
{if (pc->sz == pc->capacity){//增加容量PeoInfo* ptr= (PeoInfo*)realloc(pc->data, (pc->capacity+ INC_SZ)*sizeof(PeoInfo));if (ptr == NULL){perror("check_capacity::reallo");return;}pc->data = ptr;pc->capacity += INC_SZ;printf("增容成功!\n");}
}
void ADDContact(Contact* pc)
{assert(pc);check_capacity(pc);//增加一个人信息printf("请输入名字:>");scanf("%s", pc->data[pc->sz].name);printf("请输入年龄:>");scanf("%d", &(pc->data[pc->sz].age));printf("请输入性别:>");scanf("%s", pc->data[pc->sz].sex);printf("请输入地址:>");scanf("%s", pc->data[pc->sz].addr);printf("请输入电话:>");scanf("%s", pc->data[pc->sz].tele);pc->sz++;printf("添加成功!\n");
}
void ShowContact(const Contact* pc)
{assert(pc);int i = 0;printf("|%-20s|%-4s\t|%-5s\t|%-20s\t|%-12s|\n","名字","年龄","性别","地址","电话");printf("|--------------------|----------|-------|-----------------------|------------|\n");for (i = 0; i < pc->sz; i++){printf("|%-20s|%-4d\t|%-5s\t|%-20s\t|%-12s|\n", pc->data[i].name, pc->data[i].age, pc->data[i].sex, pc->data[i].addr, pc->data[i].tele);}
}void DelContact(Contact* pc)
{assert(pc);char name[NAME_MAX] = { 0 };if (pc->sz == 0){printf("通讯录为空,无法删除\n");return;}//删除//找到要删除的人printf("请输入要删除的人:>");scanf("%s",name);int ret=FindByName(pc, name);if (-1 == ret){printf("删除信息不存在\n");return;}int i = 0;//删除for (i = ret; i < pc->sz - 1; i++){pc->data[i] = pc->data[i + i];}printf("删除成功!\n");
}void SearchContact(const Contact* pc)
{assert(pc);char name[NAME_MAX] = { 0 };printf("请输入查找人姓名:>");scanf("%s", name);int pos = FindByName(pc, name);if (-1 == pos){printf("查找信息不存在\n");return;}printf("|%-20s|%-4s\t|%-5s\t|%-20s\t|%-12s|\n", "名字", "年龄", "性别", "地址", "电话");printf("|--------------------|----------|-------|-----------------------|------------|\n");printf("|%-20s|%-4d\t|%-5s\t|%-20s\t|%-12s|\n", pc->data[pos].name, pc->data[pos].age, pc->data[pos].sex, pc->data[pos].addr, pc->data[pos].tele);
}void ModifyContact(Contact* pc)
{assert(pc);char name[NAME_MAX] = { 0 };printf("请输入修改人姓名:>");scanf("%s", name);int pos = FindByName(pc, name);if (-1 == pos){printf("查找信息不存在\n");return;}printf("请输入名字:>");scanf("%s", pc->data[pos].name);printf("请输入年龄:>");scanf("%d", &(pc->data[pos].age));printf("请输入性别:>");scanf("%s", pc->data[pos].sex);printf("请输入地址:>");scanf("%s", pc->data[pos].addr);printf("请输入电话:>");scanf("%s", pc->data[pos].tele);printf("修改成功!\n");
}void SaveContact(Contact* pc)
{//写数据//1.打开数据FILE* pf = fopen("contact.txt", "wb");if (NULL == pf){perror("SaveContact");}else{//写数据int i = 0;for (i = 0; i < pc->sz; i++){fwrite(pc->data+i,sizeof(PeoInfo),1,pf);}fclose(pf);pf = NULL;printf("保存成功\n");}
}void LoadContact(Contact* pc)
{//读数据//1.打开文件FILE* pf = fopen("contact.txt", "wb");if (NULL == pf){perror("LoadContact");}else {//2.打开文件PeoInfo tmp = { 0 };int i = 0;while (fread(&tmp, sizeof(PeoInfo), 1, pf)){//增容check_capacity(pc);pc->data[i] = tmp;pc->sz++;i++;}fclose(pf);pf = NULL;}}

test.c - 测试通讯录

#define _CRT_SECURE_NO_WARNINGS 1
#include"contact.h"void menu()
{printf("***********************************\n");printf("*****   1. add      2. del    *****\n");printf("*****   3. search   4. modify *****\n");printf("*****   5. show     6. sort   *****\n");printf("*****   0. exit               *****\n");printf("***********************************\n");
}
int main()
{int input;//创建通讯录Contact con;//初始化通讯录InitContact(&con);do{menu();printf("请选择:>");scanf("%d", &input);switch (input){case 1:ADDContact(&con);break;case 2:DelContact(&con);break;case 3:SearchContact(&con);break;case 4:ModifyContact(&con);break;case 5:ShowContact(&con);break;case 6:break;case 0:// 保存通讯录信息到文件中SaveContact(&con);DestroyContact(&con);printf("退出通讯录\n");break;default:printf("选择错误\n");break;}} while (input);return 0;
}

6.文件的随机读写

6.1 fseek

int main()
{FILE*pf = fopen("test.txt", "r");//r：只读，需要提前创建好一个文件，//我们在文件里面写入：abcdefif (pf == NULL){perror("fopen()");return 1;}//读文件//按照顺序读int ch = fgetc(pf);printf("%c\n", ch);//找到a并读取//继续调用ch = fgetc(pf);printf("%c\n", ch);//找到d并读取//读完后指针向后移动一位fseek(pf, 1, SEEK_CUR);//从文件当前指针开始偏移1个位置（负数往前偏移，整数往后偏移）int pos1 = fgetc(pf);printf("%c\n", pos1);//打印dfseek(pf, 3, SEEK_SET);//从文件第一个元素开始向后偏移3个位置int pos2 = fgetc(pf);printf("%c\n", pos2);//打印dfseek(pf, -3, SEEK_END);//从文件最后一个元素开始往前（注意偏移量是负数）偏移3个位置int pos3 = fgetc(pf);printf("%c\n", pos3);//打印dfclose(pf);pf = NULL;return 0;
}

6.2 ftell

int main()
{FILE* pf = fopen("test.txt", "r");//我们在文件里面写入：abcdefif (pf == NULL){perror("fopen()");return 1;}fseek(pf, 3, SEEK_SET);//向后偏移了三个元素int ch = fgetc(pf);printf("%c\n", ch);int pds = ftell(pf);//这是应该指向第4个元素printf("%d\n", pds);//4fclose(pf);pf = NULL;return 0;
}

6.3 rewind

int main()
{FILE* pf = fopen("test.txt", "r");//我们在文件里面写入：abcdefif (pf == NULL){perror("fopen()");return 1;}fseek(pf, 3, SEEK_SET);//向后偏移了三个元素int ch = fgetc(pf);printf("%c\n", ch);rewind(pf);//将指针指向第一个元素int pds = ftell(pf);//这是应该指向第1个元素printf("%d\n", pds);//1fclose(pf);pf = NULL;return 0;
}

7.文本文件和二进制文件

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

数据在内存中以二进制的形式二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节

8.文件读取结束的判定

8.1 被错误使用的feof

牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。

而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
   例如：

fgetc 判断是否为 EOF .
- getc

• 如果读取正常，会返回读取到的字符的ASCII值
• 如果读取失败，EOF

fgets 判断返回值是否为 NULL .

• fgets
• 如果读取正常，返回的是存放读取到的数据的地址
• 如果读取失败，返回的是NULL

2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
   例如：

fread 判断返回值是否小于实际要读的个数

其他函数：
fscanf

• 如果读取正常，返回的是格式串中指定的数据个数
• 如果读取失败，返回的是小于格式串中指定的数据的个数

8.2 正确使用文件的例子

正确的使用文本文件的例子：

#include <stdio.h>
#include <stdlib.h>
int main(void)
{int c; // 注意：int，非char，要求处理EOFFILE* fp = fopen("test.txt", "r");if (!fp) {perror("File opening failed");return EXIT_FAILURE;}//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOFwhile ((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);![请添加图片描述](https://i-blog.csdnimg.cn/direct/0a7558e963454ed79655524615fd3428.png)}

正确使用二进制文件的例子：

#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);
}

9.文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序 中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装 满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓 冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根 据C编译系统决定的。

通俗来讲（举个例子）：
就像是在你写word文件的时候，没写一段时间，会进行一次保存，而没保存之前，文件就放在文件缓冲区中，当你点击保存后，才会放到磁盘中

这样做的原因是为了提高效率。

可以通过下面代码来测试缓冲区的存在

#include <stdio.h>
#include <windows.h>
//VS2019 WIN11环境测试
int main()
{FILE*pf = fopen("test.txt", "w");fputs("abcdef", pf);//先将代码放在输出缓冲区printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");Sleep(10000);//单位是毫秒，想当于10sprintf("刷新缓冲区\n");fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）//注：fflush 在高版本的VS上不能使用了printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");Sleep(10000);fclose(pf);//注：fclose在关闭文件的时候，也会刷新缓冲区pf = NULL;return 0;
}

这里可以得出一个结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。
如果不做，可能导致读写文件的问题。