C语言文件操作

1. 为什么使用文件

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

2. 什么是文件

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

2.1 程序文件

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

2.2 数据文件

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

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

2.3文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：文件路径+文件名主干+文件后缀
例如：:\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 );

文件的使用方法	含义	如果文件不存在	文件存在时
“r”（只读）	为了输入数据，打开一个已经存在的文本文件	出错	打开文件
“w”（只写）	为了输出数据，打开一个文本文件	建立一个新的文件	打开文件，原文件内容清空
“a”（追加）	向文本文件尾添加数据	建立一个新的文件	打开文件，只能从文件尾向文件追加数据
“rb”（只读）	为了输入数据，打开一个二进制文件	出错	打开文件
“wb”（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件	打开文件，原文件内容清空
“ab”（追加）	向一个二进制文件尾添加数据	建立一个新的文件	打开文件，从文件尾向文件追加数据
“r+”（读写）	为了读和写，打开一个文本文件	出错	打开文件
“w+”（读写）	为了读和写，建立一个新的文件	建立一个新的文件	打开文件，原文件内容清空
“a+”（读写）	打开一个文件，在文件尾进行读写	建立一个新的文件	打开文件，可从文件中读取或者往文件中写入数据
“rb+”（读写）	为了读和写打开一个二进制文件	出错	打开文件
“wb+”（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件	打开文件，原文件内容清空
“ab+”（读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件	打开文件，可从文件中读取或者往文件中写入数据

比如：

#include 
int main()
{
    FILE* pFile;
    //打开文件
    pFile = fopen("myfile.txt", "w");
    //文件操作
    if (pFile != NULL)
    {
        fputs("fopen example", pFile);
        //关闭文件
        fclose(pFile);
        pFile = NULL;//同样的pFile也是一个指针，关闭文件后还是要置为NULL，防止成为野指针。
    }
    return 0;
}

这里我们以“w”写的形式打开文件"myfile.txt"，如果我们当前路径没有这个文件的时候，系统就会自动常见一个文件：
没有执行时：

执行后，系统自动生成一个文件

如果我们要打开的不是当前路径的文件，而时打开其他地方的文件的话，我们就要填写绝对路径，比如我们要打开桌面上的文件：

点击属性查看文件，就有一个绝对路径，这个路径加上文件名就行了。

#include 
int main()
{
    FILE* pFile;
    //打开文件
    pFile = fopen("C:\\Users\\chuyang\\Desktop\\text.txt", "w");//绝对路径+文件名，注意转义
    //文件操作
    if (pFile != NULL)
    {
        fputs("fopen example", pFile);
        //关闭文件
        fclose(pFile);
        pFile = NULL;
    }
    return 0;
}

这里要注意一点就是，我们的文件路径是由"\"的，而这个是一个转义字符，所以我们就把"\"转义一下，就是"\\"。

4. 文件的顺序读写

4.1字符输出函数 fputc

作用：把字符串常量character的值写到文件指针stream所指向的文件中（不包括’\0’)，若写入成功，返回值为输出的字符，否则返回EOF。
例如：

#include 
#include 
#include 
int main()
{
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//写文件
	fputc('a',pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

我们找到我们的文件：

4.2字符输入函数 fgetc

作用：从stream所指向文件中读取一个字符，赋予变量character，如果读取文件失败返回EOF。
返回类型是int，返回的是字符的ASCII码值。
比如：

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

4.3文本行输出函数 fputs

作用：将srt所表示的字符串内容（不包括字符串最后的’\0’）输出到stream所指向的文件中去，若成功，返回一个非负数，否则返回EOF。
比如：

#include 
#include 
#include 
int main()
{
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//写文件
	fputs("hello world", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

注意：刚才我们往文件中写了一个a字符进去，但是如果我们再次写数据到文件中的时候，系统会删除原来的数据，输出现有的数据。
如果你不想删除的会，可以把打开文件的方式改成"a"

#include 
#include 
#include 
int main()
{
	FILE* pf = fopen("text.txt", "a");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//写文件
	fputs("hello world", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这个时候就会出现上一次的输出数据。

4.4文本行输入函数 fgets

作用：从stream所指向的文件中读取(n-1)个字符（第n个字符是给’\0’准备的），放到str为其实地址的储存空间（str可以是一个字符数组的数组名），若在n-1个字符前，遇到回车关键换行符或者文件结束标志，则读取操作结束，并在读入的字符串最后加上一个’\0’字符。如操作成功，返回str的起始地址，否则返回NULL。
比如：

#include 
#include 
#include 
int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//读文件
	char arr[30];
	fgets(arr, 5, pf);
	printf("%s", arr);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

注意：上面我们发现，我们给的最大个数是5，但是他只是打印了4个，原因也是很简单的，就是最后一个空间是个'\0'准备的。

4.5格式化输出函数 fprintf

作用：按format所给的输出格式，将……的值写入到stream所指向的文件中去。
这里我们和print对标一下，发现他和printf的参数只有一个之差，就是多了一个文件名。
所以我们就可以这样写：

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = { "changsan",20,50.0 };
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//写文件
	fprintf(pf, "%s %d %f", s.name, s.age, s.weight);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

4.6格式化输入函数 fscanf

作用：按照format所给出的输入控制符，把从stream中读取到的内容，分别赋值给变元……。
这里同样和scanf对标一下，fscanf也是只是多了一个文件参数。

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = {0};
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//写文件
	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.weight));
	printf("%s %d %f", s.name, s.age, s.weight);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

4.7流的概念

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

这里不知道有没有小伙伴们发现，在我们写C程序的时候，我们从屏幕上显示数据，和从键盘上输入数据的时候都没有像上述一样打开文件，输入数据，关闭文件的操作？
其实我们在写任意一个C程序的时候是默认打开了3个流的：
stdin——标准输入流（对应键盘）
stdout——标准输出流（对应屏幕）
stderr——标准错误流（对应屏幕）
这三个的类型都是FILE*的。

比如：刚才我们写的一个程序

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = {0};
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//写文件
	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.weight));
	fprintf(stdout,"%s %d %f", s.name, s.age, s.weight);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

现在我们不同printf改用fprintf也是可以子屏幕上打印出我们想要的数据的。

4.7二进制输出 fwrite

比如：

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = { "changsan",20,50.0 };
	FILE* pf = fopen("text.txt", "wb");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//二进制的方式写文件
	fwrite(&s, sizeof(struct student), 1, pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这里我们们打开文件，发现乱码了，这不是说明程序出现错误了，而是我们是以二进制的形式写入数据的，所以我们的文件存放上的是二进制数据，而这里我们能看到zhansan是因为他以二进制的形式和文本的形式放进去是一样的。

4.8二进制输入 fread

这里我们发现fread的参数和fwrite的参数是一样的。
fwrite是把大小为size个数为count的数据从ptr中写入stream。
而fread恰好是反过来的，把大小为size个数为count的数据从stream中读到prt中。

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = { 0 };
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	//二进制的形式读文件
	fread(&s, sizeof(struct student), 1, pf);
	printf("%s %d %f", s.name, s.age, s.weight);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

4.9对比一组函数scanf/fscanf/sscanf/printf/fprintf/sprintf

scanf/fscanf/sscanf
printf/fprintf/sprintf

以上两对我们前面都有所了解。主要是针对sscanf和sprintf
sprintf

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = { "changsan",20,50.0 };

	char buf[100] = { 0 };
	sprintf(buf, "%s %d %f", s.name, s.age, s.weight);
	printf("%s", buf);
	return 0;
}

sscanf

#include 
#include 
#include 
struct student
{
	char name[20];
	int age;
	float weight;
};
int main()
{
	struct student s = { "changsan",20,50.0 };
	struct student tmp = { 0 };

	char buf[100] = { 0 };
	//把s中的格式化数据转换成字符串放到buf中
	sprintf(buf, "%s %d %f", s.name, s.age, s.weight);
	printf("%s\n", buf);
	//把buf中的字符串转换成格式化数据放到tmp中
	sscanf(buf, "%s %d %f", tmp.name, &(tmp.age), &(tmp.weight));
	printf("%s %d %f", tmp.name, tmp.age, tmp.weight);
	return 0;
}

总结：

1. scanf是针对标准输入的格式化输入语句。
   printf是针对标准输出的格式化输出语句。

2. fscanf是针对所有输入流的格式化输入语句。
   fprintf是针对所有输出流的格式化输出语句。

3. sprintf把一个格式化的数据转换成字符串。
   sscanf从一个字符串中转换成一个格式化的数据。

5. 文件的随机读写

• 文件的顺序读写比较简单，也容易理解，但是又是效率不高。例如档案馆存放了几百万份档案，如果按顺序方法查找某个人的档案，工作量可想而知。因此我们必须可以从任意位置进行查找和访问。
• 文件的随机读写，是指在文件进行读写操作时，可与i对文件中指定位置的信息进行读写操作。这样就需要对文件进行详细定位，只有定位确定，才有可能对文件进行随机读写。一般地，文件的随机读写适用于有固定长度记录的文件。
• C语言提供了一组用于文件随机读写的定位函数，其函数原型在stdio.h中。采取随机读写文件的方法可以在不破坏其他数据的情况下把数据插入到文件中去，也可以子啊不重写整个文件的情况下更新和删除以前的数据。

5.1fseek

参数有三个，主要是观察offset和origin两个参数。

• offset表示偏移量，规定
  1.offset>0，表示stream向前（向文件尾）移动。
  2.offset<0，表示stream向后（向文件头）移动。

• origin表示文件移动的起始位置。
  1.SEEK_SET 或者 pos=0，表示文件指针在文件的开始。
  2.SEEK_CUR 或者 pos=0，表示文件指针在当前文件指针的位置。
  3.SEEK_END 或者 pos=0，表示文件指针在文件尾。
  我们可以将他们转到定义观察。

作用：把文件指针stream一到年关到fromwhere为offset个字节的地方，其中offset为长整型数据，表示偏移量，若定位成功返回0；若定位失败，返回非零值。

例如：
我们文件先存放abcdef。

现在我们向从c开始拿到数据。我们就可以这样写。

int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
	}
	fseek(pf,2,SEEK_SET);
	int ch = fgetc(pf);
	printf("%c", ch);
	fclose(pf);	
	pf = NULL;
	return 0;
}

这里就表示从SEEK_SET文件的开始位置向右偏移两个字节，就找到字符c。

5.2ftell

作用：计算stream所指向位置距离文件头的偏移量，如果正确返回偏移量，否则返回-1L。
例如：

int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
	}
	fseek(pf,2,SEEK_SET);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	printf("%d", ftell(pf));
	fclose(pf);	
	pf = NULL;
	return 0;
}

我们刚才把文件指针地位到了字符c处，而打印完后，文件指针就会自动向后查找，这个之后就找到了d，而d距离文件起始位置的偏移量就是3。

5.3rewind

作用：将文件指针stream重新回到文件的开始位置。

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

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

一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而
二进制形式输出，则在磁盘上只占4个字节。

如果我以二进制的形式存放10000只需要花费4个字节，但是以ASCII码形式存放的话需要花费5个字节。

例如：

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

这里我们用的是二进制的形式写进去的，用文本文件时看出来的，我们要以二进制的形式才能观察到。

这里我们就可以看到这个以十六进制形式的数，转换成十进制的就是10000.

7. 文件读取结束的判定

7.1 被错误使用的feof

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

1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
   例如：
   fgetc 判断是否为 EOF .
   fgets 判断返回值是否为 NULL .
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
   例如：
   fread判断返回值是否小于实际要读的个数。

7.2 feof

作用：判断文件位置指针当前是否出于文件结束位置。当文件于文件结束位置时，返回非零值，否则返回0.

7.3 ferror

作用：检查文件在使用的输入输出函数（如putc，getc，fread，fwrite）进行读写时，是否有错位发生。如果没有错误返回零值；如果出错返回非零值。在执行fopen函数时，ferror函数的初始值将被被自动置为0。

8. 文件缓冲区

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

这里我们可以看到，我们程序虽热已经执行了，但是我们的文件中是没有内容的，这也就说明了，我们写入数据不是直接写到文件中的，而是先放到文件缓冲区，存放好，等存放一定空间后，一起放到文件中。

我们用fflush函数刷新一下缓冲区，在观察一下文件，就可以看到数据了。

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