1.为什么使用文件

在学习结构体时，写了一个简易的通讯录的程序，当程序运行起来的时候，可以在通讯录中增加和删除数据，此时数据是存放在内存当中的，当程序退出的时候，通讯录中的数据自然就不存在了，等下次通讯录运行的时候，数据又得重新录入了，这样的通讯录使用起来会有点难受。

所以应该通讯录应该要能够把数据给记录下来，只有选择删除的时候，数据才不复存在。而这就涉及到了数据持久化的问题，一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

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

2.什么是文件

磁盘上的文件是文件。

但是在程序设计中，文件可以分为两种：程序文件和数据文件（从文件功能的角度来分类）

2.1程序文件

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

平时用来写C语言代码的那个文件就是源程序文件

可执行程序就是代码运行起来后弹出的那个黑框框

目标文件就是可执行程序在形成过程中生成的文件

2.2数据文件

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

以下的内容基本都是围绕这个数据文件来展开的，而在之前所处理数据的输入以及输出都是以终端（终端就是输入输出设备）为对象的，即从终端的键盘上输入数据，运行结果输出（显示）到显示器上。

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

2.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指向某个文件的文件信息区（一个结构体变量），通过该文件信息区中的信息就能够访问该文件，也就是说，通过文件指针变量能够找到与他关联的文件。

如图：

每个文件在打开的时候都会在内存中开辟一个文件信息区，这个文件信息区就是FILE结构体类型的变量，而此时文件指针就会指向这个变量。

3.2文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。

在编写程序的时候，在打开文件的同时，都会放回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。

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

打开文件：

FILE* fopen(const char* filename, const char* mode);

关闭文件：

int fclose (FILE* stream); 

用只写的方式打开文件：

代码如下：

#include <stdio.h>
 
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)//遇到错误时函数会返回NULL指针
	{
		perror("fopen");
		return 1;
	}
	//文件操作
	// 
	//关闭文件
	fclose(pf);
	pf = NULL;//把文件指针置空，防止野指针的问题
	return 0;
}

在相应的目录下创建了一个test.txt文件，如果文件不存在，则进行创建，如果文件存在，则对文件的内容进行销毁

用只读的方式打开文件：

代码如下：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	//文件操作
	// 
	//关闭文件
	fclose(pf);
	pf = NULL;//把文件指针置空，防止野指针的问题
	return 0;
}

相应的目录下必须要存在这个test.txt文件，否则编译器会报错。

注意：在相应的目录下查看文件时要在查看中打开文件扩展名

以上fopen函数中的文件名参数写的都是相对路径，如果要写绝对路径的话要从对应的根目录开始写。

4.文件的顺序读写

先来认识一些输入和输出函数：

这里的输出流和输出流是一个抽象的概念，比如说一些外部设备如键盘、显示器、U盘等等，这些设备的输入和输出方式都是不同的，这个时候C语言中的库将这些输入和输出的方式都封装成一个流，只需要知道这个流就能完成一个输入和输出，而不用去学习硬件上的其他知识。

再打开编译器的时候，会默认打开三个流，分别是标准输入流、标准输出流和标准错误流

标准输入流：stdin，指的是键盘

标准输出流：stdout，指的是屏幕

标准错误流：stderr，也是屏幕

接下来具体讲讲输入和输出函数

字符输出函数：

int  fputc(int c, FILE* stream);

fputc会返回被输出字符的ASCII码值，遇到错误时返回EOF。 

#include <stdio.h>
 
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	char ch = 0;
	for (ch = 'a'; ch <= 'z'; ch++)
	{
		fputc(ch, pf);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

将字符a到z写到文件当中，也可以理解为将数据输出到文件里面，因为适用于所有输出流，所以这里的参数可以用文件流，文件流也是文件指针。

此时可以查看test.txt里面的数据：

 字符输入函数：

int fgetc(FILE* stream);

fgetc会返回读到的字符的ASCII码值，当读到文件末尾或者遇到错误时会返回EOF。

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == EOF)
	{
		perror("fopen");
		return 1;
	}
	//读文件 - 输入操作
	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c ", ch);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

从刚刚写的test.txt中读取信息，也就是从test.txt上的数据输入到了ch中，并在屏幕上输出。

可以将键盘和显示器作为输入和输出的参数：

int main()
{
	int ch = fgetc(stdin);
	fputc(ch, stdout);
	return 0;
}

文本行输出函数：

int fputs(const char* string, FILE* stream);

成功则返回非负指，遇到错误则返回EOF

int main()
{
	//打开文件
	FILE* pf = fopen("test1.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fputs("abcdefg\n", pf);
	fputs("hijklmn\n", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

将字符串输出到文件中
  

 此时打开test1.txt查看数据：

如果输出流写stdout，可以输出到屏幕上来

文本行输入函数：

 char* fgets(char* string, int n, FILE* stream);

将输入的数据存储到string，会最多读取n-1个字符，最后1个字符为'\0'，返回值为读取到的字符串，遇到错误时或EOF时返回NULL指针。

int main()
{
	//打开文件
	FILE* pf = fopen("test1.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	char arr[256] = { 0 };
	while (fgets(arr, 256, pf) != NULL)
	{
		fputs(arr, stdout);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

将刚才test1.txt里面的内容作为输入的数据，然后在屏幕上将数据输出。

格式化输出函数：

int fprintf( FILE *stream, const char *format [, argument ]...); 

和printf很像，只是printf的默认输出流是标准输出流，而这里的参数stream适用于所有的输出流

struct S
{
	char name[20];
	int age;
	double score;
};
 
int  main()
{
	struct S s = { "zhangsan", 20, 75.5 };
	//打开文件
	FILE* pf = fopen("test2.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fprintf(pf, "%s %d %f", s.name, s.age, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

此时已经把数据写入到了test2.txt里面，打开文件来查看一下：

 同样的，stream位置的参数可以是标准输出流，这样数据就会输出到屏幕上面来了

struct S
{
	char name[20];
	int age;
	double score;
};
 
int  main()
{
	struct S s = { "zhangsan", 20, 75.5 };
	fprintf(stdout, "%s %d %f", s.name, s.age, s.score);
	return 0;
}

格式化输入函数：

int fscanf( FILE *stream, const char *format [, argument ]... ); 

fscanf和scanf和很像，只是scanf默认stream位置的参数是标准输入流，也就是键盘。

int  main()
{
	struct S s = {0};
	//打开文件
	FILE* pf = fopen("test2.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	fscanf(pf, "%s %d% lf", s.name, &(s.age), &(s.score));
	fprintf(stdout, "%s %d %lf", s.name, s.age, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

 将数据从文件上读取，然后在屏幕上输出。

 再来认识两个与printf和scanf很像的函数：

sprintf：将格式化的数据转换为字符串

int sprintf( char *buffer, const char *format [, argument] ... );

 sscanf：将字符串转换为格式化的数据

int sscanf( const char *buffer, const char *format [, argument ] ... );

sprintf的使用：

struct S
{
	char name[20];
	int age;
	double score;
};
 
int main()
{
	char buf[256] = { 0 };
	struct S s = { "wangwu", 30, 85.5 };
	sprintf(buf, "%s %d %lf", s.name, s.age, s.score);
	printf("%s\n", buf);
	return 0;
}

将结构体的数据转换为字符串存入buf中，然后将buf在屏幕上输出出来。 

 

 sscanf的使用：

struct S
{
	char name[20];
	int age;
	double score;
};
 
int main()
{
	char buf[256] = { 0 };
	struct S s = { "wangwu", 30, 85.5 };
	sprintf(buf, "%s %d %lf", s.name, s.age, s.score);
	//将字符串转化为格式化的数据
	struct S tmp = { 0 };
	sscanf(buf, "%s %d %lf", tmp.name, &(tmp.age), &(tmp.score));
	printf("%s %d %lf", tmp.name, tmp.age, tmp.score);
	return 0;
}

 

也可以认为是从字符串中提取数据存入到结构体tmp中来。

这里列在一起方便对比一下：

 二进制输出函数：

size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );

buffer：指向被读取的数据的指针

size：被读取的项目的字节大小

count：被读取的项目数的最大值

stream：文件流

fwrite的使用：

struct S
{
	char name[20];
	int age;
	double score;
};
 
int main()
{
	struct S s = { "lisi", 15, 95.5 };
	//打开文件
	FILE* pf = fopen("test3.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fwrite(&s, sizeof(struct S), 1, pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

 因为是以二进制的方式写的，所以文件中存放的数据是这样子的：

二进制输入函数：

size_t fread( void *buffer, size_t size, size_t count, FILE *stream ); 

跟fwrite相反，将文件中的数据作为输入数据存储到buffer指向的空间中。

fread的使用：

struct S
{
	char name[20];
	int age;
	double score;
};
 
int main()
{
	struct S s = { 0 };
	//打开文件
	FILE* pf = fopen("test3.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	fread(&s, sizeof(struct S), 1, pf);
	printf("%s %d %lf\n", s.name, s.age, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

5.文件的随机读写

5.1fseek

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

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

stream：文件流

offset：相对于此时文件指针的位置的偏移量，单位是字节

origin：文件指针此时的位置

origin可以分为3个值：

SEEK_CUR - 文件指针当前的位置

SEEK_SET - 文件开始的位置

SEEK_END - 文件末尾的位置

先在对应的目录下创建一个test.txt文件，往里面写入a到f的字符

#include <stdio.h>
 
int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//把a到f的字符写入文件
	char ch = 0;
	for (ch = 'a'; ch <= 'f'; ch++)
	{
		fputc(ch, pf);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

fseek的使用：

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//让文件指针从此时的位置向后移动5个字节
	fseek(pf, 5, SEEK_CUR);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	fclose(pf);
	pf = NULL;
	return 0;
}

找到f的位置并将其读取，输出在屏幕上,结果是f

offset输入负值也可以让指针往前走

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//让文件指针从文件尾的位置向前移动3个字节
	fseek(pf, -3, SEEK_END);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	fclose(pf);
	pf = NULL;
	return 0;
}

最终屏幕上输出的结果是d

注意：文件末尾是f之后的那个位置

5.2ftell

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

long int ftell ( FILE * stream );

ftell的使用： 

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fseek(pf, 0, SEEK_END);
	long size  = ftell(pf);
	printf("%ld\n", size);
	fclose(pf);
	pf = NULL;
	return 0;
}

对于test.txt这个文件，文件指针末尾的位置相对于起始位置是6.

使用比较简单，了解一下即可

5.3rewind

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

void rewind( FILE *stream ); 

rewind的使用：

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fseek(pf, 0, SEEK_END);
	//从文件尾回到文件起始位置
	rewind(pf);
	long size  = ftell(pf);
	printf("%ld\n", size);
	fclose(pf);
	pf = NULL;
	return 0;
}

文件指针先是走到文件末尾，最后回到起始位置，所以最终屏幕输出结果是0

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

 根据数据的储存形式，数据文件被称为文本文件和二进制文件。

数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。外存可以理解为硬盘。

如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。前面fputc就是以ASCII字符的形式将数据存储在文件中。

下面来看一个数据在内存中是怎么存储的

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

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

直接在记事本中输入10000，就是以ASCII码的形式进行存储。

可以将这个文件在编译器中打开

然后选择二进制的打开方式：

然后可以看到显示的结果是将二进制的形式转换为十六进制的形式

刚好对应着10000的ASCII码的存储形式

接下来看看以二进制的形式存储：

 

int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int a = 10000;
	fwrite(&a, sizeof(int), 1, pf);//二进制的形式写
	fclose(pf);
	pf = NULL;
	return 0;
}

再以二进制的形式打开test.txt

 由于该编译器是小端字节序存储，所以可以看到16进制显示的数字是反过来的。

7.文件读取结束的判定

7.1被错误使用的feof

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

文件的读取结束判断：

文本文件的读取结束判断：

fgetc函数判断返回值是否为EOF

fgets函数判断返回值是否为NULL

二进制文件的读取结束判断：

fread判断返回值（实际读到的个数）是否小于预计要读的个数

feof和ferror函数

feof

int feof( FILE *stream ); 

 文件是由于读取到文件尾结束时返回一个非0值，反之返回0

ferror

int ferror( FILE *stream );

文件是由于读取错误而读取结束时返回一个非0值，反之返回0

 

文本文件的读取结束判断代码：

int main()
{
	int c; // 注意：int，非char，要求处理EOF
	FILE* fp = fopen("test.txt", "r");
	if (fp == NULL)
	{
		perror("fopen");
		return 1;
	}
	//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);
	fp = NULL;
	return 0;
}

二进制文件的读取结束判断代码：

enum
{ 
	SIZE = 5 
};
 
int main(void)
{
	double a[SIZE] = { 1.,2.,3.,4.,5. };
	FILE* fp = fopen("test.txt", "wb");
	if (fp == NULL)
	{
		perror("fopen");
		return 1;
	}
	fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组
	fclose(fp);
	fp = NULL;
 
	double b[SIZE];
	fp = fopen("test.txt", "rb");
	size_t ret_code = fread(b, sizeof * b, SIZE + 1, fp); // 读 double 的数组
	if (ret_code == SIZE) 
	{
		puts("Array read successfully, contents: ");
		for (int n = 0; n < SIZE; ++n) 
		printf("%f ", b[n]);
		putchar('\n');
	}
	if (feof(fp))//判断是否因为遇到文件尾造成的文件读取结束
		printf("Error reading test.txt: unexpected end of file\n");
	else if (ferror(fp)) //判断是否因为读取失败造成的文件读取结束
	{
		perror("Error reading test.txt");
	}
	fclose(fp);
	fp = NULL;
}

8.文件缓冲区

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

图解：

int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fputs("abcdef", pf);//先将代码放在输出缓冲区
	printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
	Sleep(10000);
	printf("刷新缓冲区\n");
	fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
	printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
	Sleep(10000);//此时睡眠10秒，是为了说明数据是由于fflush的刷新才输出到文件中的
	fclose(pf);
	//注：fclose在关闭文件的时候，也会刷新缓冲区
	pf = NULL;
	return 0;
}

fflush函数可以让数据不充满缓冲区时就直接输入或者输出

结论：

因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件，如果不做，可能会导致读写文件时数据不完全读写的问题。

关于C语言的文件操作内容就讲到这里了，今后也会不定期更新