C · 进阶 | 慎看！深剖文件操作，怕你停不下

啊我摔倒了..有没有人扶我起来学习....

---

---

前言

• 我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受
• 我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
• 这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式
• 使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化

---

一、 什么是文件

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

1.1 程序文件

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

1.2 数据文件

• 文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件
• 本文讨论的是数据文件
• 在以前各章节内容所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上
• 其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件

1.3 文件名

• 一个文件要有一个唯一的文件标识，以便用户识别和引用
• 文件名包含3部分：文件路径+文件名主干+文件后缀
  例如： c:\code\test.txt
  为了方便起见，文件标识常被称为文件名

二、文件的打开和关闭

2.1 文件指针

• 缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”

• 每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE
  

• 例如，VS2013编译环境提供的 stdio.h 头文件中有以下的文件类型申明：不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异

struct _iobuf 
{
	char* _ptr;
	int   _cnt;
	char* _base;
	int   _flag;
	int   _file;
	int   _charbuf;
	int   _bufsiz;
	char* _tmpfname;
};
typedef struct _iobuf FILE;
1
2
3
4
5
6
7
8
9
10
11
12

• 每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节
• 一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便

下面我们可以创建一个FILE*的指针变量：

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

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

比如：

2.2 文件的打开和关闭

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

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

打开方式如下：

实例代码：

/* fopen fclose example */
#include
#include 
#include 

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//...
	//读文件

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fopen("test.txt", "r")该路径下是相对路径，也就是和源文件（.c）在同一个文件夹里

如果该路径下没有test.txt，看看会不会报错：

果然报错了，提示没有该文件

那如果该路径下没有test.txt，我们直接写文件呢：

#include
#include 
#include 

int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//...
	//写文件


	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运行上述写文件的代码：
没有报错！
原来，会自动生成这个文件

• 不过此时test.txt文件中没有东西，因为我们只是打开了这个文件，告诉编译器我将要写东西进去，但是还没开始写
  

• 有没有发现这跟动态内存管理很相似，没错，打开文件也会占用一定的内存，关闭了才会释放，不关闭的话一样会造成内存泄露，还可能丢失文件的数据

三、文件的顺序读写

3.0 有必要解释一下*

1. 上图所指的输入输出，是对内存而言的，可以把内存当做第一人称。文件是在硬盘里（也就是外存），所以对文件的读，就是输入，对文件的写，就是输出；另外，内存和终端（屏幕、键盘等）也是这种关系
   
2. • 其实内存与文件不是直接交互的，而是通过桥梁——流
   • 流的存在是因为，与内存交互的外部设备不只有硬盘，还有软盘，U盘，网络，光盘，屏幕鼠标等等。每一种外部设备的读写方式都不同，如果程序员都需要学，那就太麻烦啦。所以程序员只需要把读写交给流，流会自动处理（工具流）
   • 下面会学到一些读写文件的函数，函数参数里的stream就是“流”；而文件指针FILE* pf其实也是流
   • stream是函数形参，FILE* pf是实参，它俩的关系就是这样
     
3. • 既然文件在外部设备硬盘里，操作它需要打开和关闭，一旦打开就会有对应的流出来维护。但是键盘、屏幕不也是外部设备，为啥就没听说过打开关闭键盘和屏幕呢（打开关闭电源不算…不要杠）？
   • 因为任何一个C程序只要运行，就会默认打开三个流：

3.1 fputc

• 咦？？不是字符输出函数吗，怎么参数character是整型？其实这是字符的ASCII码值。所以这个函数的意思是把一个字符输出给指针stream所指的文件

下面我们用循环写入多个字符：

#include
#include 
#include 

int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//...
	//写文件
	for (int i = 'a'; i <= 'f'; i++)
	{
		fputc(i, pf);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行看看：
终端没有报错，说明写入成功！我们打开test.txt文件看看：

果然写进去了

3.2 fgetc

咱们试试从test.txt读一个字符：

#include
#include 
#include 

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//...
	//读文件
	fgetc(pf);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 没有报错，读取成功！但是我们却看不到读取的字符啊？
• 因为这里（3.0 有必要解释一下）已经解释过了，fgetc是把文件中的字符输入给内存，没打印到屏幕上所以我们看不到，想看到怎么就打印一下：

#include
#include 
#include 

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//...
	//读文件
	int ch = fgetc(pf);
	printf("%c", ch);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这不就看到啦！

• 可以发现，文件里是abcdef，但是只读到了a，只能一个一个读。所以可以构造一个循环读取全部字符：

#include
#include 
#include 

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//...
	//读文件
	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c ", ch);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 剩下的fgets、fputs就是针对字符串的，铁汁们可以自己试试

3.3 fprintf

• 我们想想，读写文件有字符、字符串，那如果再复杂一点的呢？比如结构体的读写，于是就有了fprintf和fscanf
• 先来看看fprintf
  
• 可以看到fprintf只是比printf多出一个参数——流，试试看：

#include
struct S
{
	char arr[10];
	int age;
	float score;
};
int main()
{
	struct S s = { "bobo",25,99.6f };

	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//...
	//读文件
	fprintf(pf,"%s %d %f", s.arr, s.age, s.score);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

没有报错，写入文件成功！打开文件看看：

3.4 fscanf

• 可以看到fscanf只是比scanf多出一个参数——流，试试看：

1. 我们先把结构体初始化为0

	struct S s = { 0 };
1

2. test.txt文件里还存着刚刚打印的信息，现在我们看看fscanf是否能把文件中的信息读取到内存（这里用结构体储存）中

#include
struct S
{
	char arr[10];
	int age;
	float score;
};
int main()
{
	struct S s = { 0 };

	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//...
	//读文件
	fscanf(pf,"%s %d %f",s.arr,&(s.age),&(s.score));

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

-没有报错，读取成功！但是没打印出来？还是一样，只是读取存到内存中而已，可以用printf打印一下结构体看看是否存进来了：

printf("%s %d %f",s.arr,s.age,s.score);
1

• 没错叭~

3.4.1来个小总结（这里忽略作为桥梁的流）：

• 根据3.0所提到的标准输入输出流，可以发现，我们不需要打开键盘和屏幕就可以直接使用printf和scanf，因为是系统默认打开的。
• 诶？那我可不可以把用fprintf来打印数据到屏幕上？
• 答案是可以的。只需要把fprintf的第一个参数（本来用的是pf）改成标准输出流stdout

改造一下上述代码，试试看：

fprintf(stdout,"%s %d %f",s.arr,s.age,s.score);
1

• 果然可以！！！

3.5 fread与fwrite

• 前面所讲函数针对所有输入流或所有输出流（就是可以用于键盘、屏幕、网络、文件等等外部设备与内存之间的交互）
• 而这两个函数只针对文件
• 具体操作和之前的几个大同小异，铁汁们自己练习，知道有这么个东西就好，想用的时候直接查查参数cplusplus.com

四、文件的随机读写

• 以上函数的文件指针都是从头开始顺序读取数据，如果想要在指定位置读取，就可以使用以下函数
• 接下来的几个也是了解了解就好

4.1 fseek

• 根据文件指针的位置和偏移量来定位文件指针

int fseek ( FILE * stream, long int offset, int origin );
1

例子：

/* fseek example */
#include 
int main()
{
	FILE* pFile;
	pFile = fopen("example.txt", "wb");
	fputs("This is an apple.", pFile);
	fseek(pFile, 9, SEEK_SET);
	fputs(" sam", pFile);
	fclose(pFile);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

4.2 ftell

• 返回文件指针相对于起始位置的偏移量

long int ftell ( FILE * stream );
1

例子：

/* ftell example : getting size of a file */
#include 
int main()
{
	FILE* pFile;
	long size;
	pFile = fopen("myfile.txt", "rb");
	if (pFile == NULL) perror("Error opening file");
	else
	{
		fseek(pFile, 0, SEEK_END);   // non-portable
		size = ftell(pFile);
		fclose(pFile);
		printf("Size of myfile.txt: %ld bytes.\n", size);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.3 rewind

• 让文件指针的位置回到文件的起始位置

void rewind ( FILE * stream );
1

例子：

/* rewind example */
#include 
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

• 根据数据的组织形式，数据文件被称为文本文件或者二进制文件
• 数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件
• 如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件
• 一个数据在内存中是怎么存储的呢？
  • 字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储
  • 如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2013测试）
    

测试代码：

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

1. 运行上述代码，然后打开test.txt文件。因为是二进制写入的所以看不懂
   
2. 用VS添加test.txt文件，打开二进制编辑器
   
   
   
   
   

六、 文件读取结束的判定

7.1 被错误使用的feof

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

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

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

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

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

3. 正确的使用：

文本文件的例子：

#include 
#include 
int main(void) {
	int c; // 注意：int，非char，要求处理EOF
	FILE* fp = fopen("test.txt", "r");
	if (!fp) {
		perror("File opening failed");
		return EXIT_FAILURE;
	}
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这里是遇到文件末尾而正常结束：

二进制文件的例子：

#include 
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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这里是遇到文件末尾而正常结束：

七、文件缓冲区

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

可以用下述代码测试缓冲区的存在：

#include 
#include 
//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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 在关闭文件前又等十秒，是因为关闭文件时也会刷新，哪怕缓冲区没满也会直接把数据都弄到文件里，这样就观察不到效果了
  
• 这里可以得出一个结论：
• 因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题

---