我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就没有意义了，这时候就能用文件的方法，将数据以文件的方式存放在电脑的硬盘上，做到了数据的持久化。

二、什么是文件？

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

1、程序文件

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

2、数据文件

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

在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。

3、文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。文件名包含3部分：文件路径+文件名主干+文件后缀

例如： C:\code\test\test.txt

文件路径：C:\code\test\test.txt

文件名主干：test

文件后缀： .txt

三、文件操作

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;

每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。

一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。

下面创建一个文件指针变量：

FILE* pf;//文件指针变量

定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

因为在这里每一个文件类型的指针，指向对应的一个文件信息区，每个文件信息区里存放着对应文件的数据，而通过这个指针就可以访问这个文件信息区，这样就可以给文件进行一系列的操作。

2、文件打开与关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。

ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件。

//打开文件
FILE* fopen(const char* filename, const char* mode);
//关闭文件
int fclose(FILE* stream);

文件的打开方式如下：

文件使用方式	含义	如果指定文件不存在
“r”(只读)	为了输入数据，打开一个已经存在的文本文件	出错
“w”（只写）	为了输出数据，打开一个文本文件	建立一个新的文件
“a”（追加）	向文本文件尾添加数据	建立一个新的文件
“rb”（只读）	为了输入数据，打开一个二进制文件	出错
“wb”（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
“ab”（追加）	向一个二进制文件尾添加数据	出错
“r+”（读写）	为了读和写，打开一个文本文件	出错
“w+”（读写）	为了读和写，建议一个新的文件	建立一个新的文件
“a+”（读写）	打开一个文件，在文件尾进行读写	建立一个新的文件
“rb+”（读写）	为了读和写打开一个二进制文件	出错
“wb+”（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
“ab+”（读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件

举个例子：

#include <stdio.h>
int main()
{
    //打开文件
    FILE* pFile = fopen("myfile.txt", "w");//只写
    if(pFile == NULL)
    {
        perror("fopen");
        return 1;
    }
    //文件操作
    fputs("fopen example", pFile);
    //关闭文件
    fclose(pFile);
    return 0;
}

3、文件的顺序读写

我们发现内存和外部设备或者文件之间进行数据的传输过程类似水流一样，这些数据不断地流入内存之中，又不断地流出内存。那么数据流入内存的过程叫做输入流，数据流程内存的过程叫做输出流。

功能	函数名	适用于
字符输入函数	fgetc	所有输入流
字符输出函数	fputc	所有输出流
文本行输入函数	fgets	所有输入流
文本行输出函数	fputs	所有输出流
格式化输入函数	fscanf	所有输入流
格式化输出函数	fprintf	所有输出流
二进制输入	fread	文件
二进制输出	fwrite	文件

3.1 fputc()和fgetc()函数的使用

//fputc的使用
#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("text.txt", "w");//只写
	if (pf == NULL)
	{
		perror("fopen");
	}
	//将26个字母写入文件中
	for (int i = 0; i < 26; i++)
	{
		fputc('a' + i, pf);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
}

//fgetc的使用
#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("text.txt", "r");//只读
	if (pf == NULL)
	{
		perror("fopen");
	}
	//将文件中的26个字母读取回来,并打印出来。
	for (int i = 0; i < 26; i++)
	{
		int c = fgetc(pf);
		printf("%c", c);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

3.2 fputs()和fgets()函数的使用

//按照顺序写文本行
#include <stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件 --- 一行一行写
	fputs("hello\n", pf);
	fputs("hello world\n", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

//按照顺序读文本行
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件 --- 一行一行读
	char arr[20] = { 0 };
	fgets(arr, 20, pf);
	printf("%s", arr);//将读取的数据打印到屏幕上
	fgets(arr, 20, pf);
	printf("%s", arr);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

3.3 fscanf()和fprintf()函数的使用

//写一个结构体的数据
#include <stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	//创建一个结构体变量
	struct S s = { "张三",20,95.5f };
	//把s中的数据写到文件中
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fprintf(pf, "%s %d %.2f", s.name, s.age, s.score);
	//关闭文件
	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 (pf == NULL)
	{
		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;
}

由于fscanf和fprintf适用于所有流，那么自然也适用于标准的输入输出流，我们也可以通过一下函数获取数据，并打印在屏幕上。

fscanf(stdin , "%d" , &a);
fprintf(stdout , "%d" , a);

3.4 fread()和fwrite()函数的使用

//二进制的形式，写一个结构体的数据
#include <stdio.h>
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = { "张三",20,95.5f };
	//把s中的数据写到文件中
	FILE* pf = fopen("test.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//二进制的写文件
	fwrite(&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 (pf == NULL)
	{
		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;
}

3.5对比三组函数

4、文件的随机读写

4.1 fseek()函数

函数的使用

int main()
{
	//打开文件
	FILE* pf = (FILE*)fopen("text.txt", "w");//只写
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	for (int i = 0; i < 6; i++)
	{
		fputc('a' + i, pf);
	}
	fclose(pf);
	pf = NULL;
 
	FILE* p = fopen("text.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return 1;
	}
	fseek(p, 2, SEEK_SET);
	printf("%c", fgetc(p));
	fclose(p);
	p = NULL;
	return 0;
}

4.2 ftell()函数

当我们多次的调整文件指针位置的时候，有时候我们会忘记文件指针指向哪里。这个时候用ftell函数就能发挥它的作用了，这个函数就是来反馈文件指针相对于起始位置的偏移量。

函数的使用：

int main()
{
    FILE* p = fopen("text.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return 1;
	}
	fseek(p, -2 , SEEK_END);
	printf("%c", fgetc(p));
	printf("\n");

	int a = ftell(p);
	printf("当前文件指针相对于起始位置的偏移量：%d", a);

	fclose(p);
	p = NULL;
    return 0;
}

4.3 rewind()函数

这个函数的作用就是重置文件指针的位置，将其再次指向文件中的第一个元素。

函数的使用：

int main()
{
	FILE* p = fopen("text.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return 1;
	}
	fseek(p, -2 , SEEK_END);
	printf("%c", fgetc(p));
	printf("\n");

	int a = ftell(p);
	printf("当前文件指针相对于起始位置的偏移量：%d", a);
	printf("\n");

	rewind(p);//因为它的返回类型为void
	int b = ftell(p);
	printf("当前文件指针相对于起始位置的偏移量：%d", b);

	fclose(p);
	p = NULL;
    return 0;
}

运行结果如下：

5、文本文件和二进制文件

字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

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

1、数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。

2、如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

下列是将10000的二进制形式写入文本中

int main()
{
	int a = 10000;
	FILE* pf = fopen("test.txt", "wb");
	fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
	fclose(pf);
	pf = NULL;
	return 0;
}

上述操作完成以后就能看见下面的形式

它是将二进制转化成十六进制的形式，所以就呈现出 10 27 00 00。

6、文件读取结束判定

注意：

在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

(1)文本文件读取是否结束，判断返回值是否为 EOF（ fgetc ），或者 NULL （ fgets ）。

例如：

fgetc 判断是否为 EOF 。
fgets 判断返回值是否为 NULL 。

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

例如：

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

在这里我们要注意一个库函数，叫feof函数。这个函数不是用来判断文件是否读到文件尾的，而是判断是以何种方式到达文件尾的。也就是说，feof判断的是这个文件是以出现错误而结尾还是以读到文件尾部而结尾的。

介绍两个函数feof()和ferror()函数的具体用法：

函数feof()在到达给出的文件流的文件尾时返回一个非零值。
当读取结束后可以用此函数可以判断文件指针是否在文件末尾结束，如果是，返回非零值。如果不是，则返回零值。

ferror()函数检查stream(流)中的错误,，如果没发生错误返回0，否则返回非零.。如果发生错误，使用perror()检测发生什么错误。

文本文件的例子：

int main()
{
	//创建一个文件并写入6个字母
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
	}
	for (int i = 0; i < 6; i++)
	{
		fputc('a' + i, pf);
	}
	fclose(pf);
	pf = NULL;
	//读取这个文件中的6个字母
	FILE* p = fopen("test.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
	}
	int a = 0;
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((a = fgetc(p)) != EOF)//标准C I/O读取文件循环
	{
		printf("%c", a);
	}
	printf("\n");
	//判断文件读取结束的原因：出错或者读完
	if (ferror(p))
	{
		printf("I/O error when reading\n");
	}
	if (feof(p))
	{
		printf("End of file reached successfully\n");
	}
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

二进制文件的例子：

int main()
{
    double a[5] = { 1.0,2.0,3.0,4.0,5.0 };
    double b = 0.0;
    size_t ret = 0;
    FILE* pf = fopen("test.txt", "wb"); // 必须用二进制模式
    fwrite(a, sizeof(*a), 5, pf); // 将 a 数的元素写到test.txt文件中
    fclose(pf);
    pf = fopen("test.txt", "rb");
    // 将 a 数组的元素读到变量 b 中，返回值为读取数据的个数
    while ((ret = fread(&b, sizeof(double), 1, pf)) >= 1)
    {
        printf("%lf\n", b);
    }
    if (feof(pf))
    {
        printf("Error reading test.bin: unexpected end of file\n");
    }
    else if (ferror(pf))
    {
        perror("Error reading test.bin");
    }
    fclose(pf);
    pf = NULL;
    return 0;
}

四、文件缓冲区

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

缓冲区的存在可以有效地提高性能，因为在非必要情况下，需要等到缓冲区满或者程序结束前关闭文件后才将数据输入输出到程序中。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;
}

上述代码可以得出一个结论：