【C语言】文件操作总结

前言

很多人刚学到C语言文件操作的时候会觉得这部分的内容太杂了
需要记住的东西很多，没关系，我们一篇文章帮你重新梳理文件操作重要的知识
这篇文章可以当成一篇笔记看，忘记的时候可以再翻翻。
用多了自然就水到渠成。

1. 为什么使用文件？

平时我们在运行C程序的时候，你每次运行，是不是上一次运行的结果就没了。
就好像我们做了一个游戏，你运行的时候玩了一会，却没有办法存储起来，
下一次想玩的时候却要重新运行，重新开始玩。
是不是很麻烦？
因为这些数据是存放到内存中的，当程序执行结束，这些内存自然就释放掉了。
那我们如何把这些信息记录下来？只有我们主动删除数据时，这些数据才真正被删掉呢？

这就涉及到数据持久化的问题了。
一般数据持久化的方法有：
1.把数据存放到磁盘文件中。
2.存放到数据库等方式

在这篇文章，我们使用文件将内存中的数据存放到电脑磁盘上
实现文件持久化

2. 什么是文件？

磁盘上的文件叫做文件。
比如我们打开C盘，会看到各种各样的文件。
在程序设计中，从文件功能的角度分类的话，一般有两种文件：
1.程序文件
2.数据文件

2.1 程序文件

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

2.2 数据文件

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

          仔细推敲这句话，什么叫程序运行时读写的数据？
          举个例子。

就是说，数据文件是供程序运行使用的，我们可以从中读取数据，
也可以写入数据

                这篇文章，我们主要讲的就是数据文件

2.3 输入输出的类比

刚接触C语言时，我们的输入输出都是以终端为对象的，
即键盘和屏幕都是终端对象。
我们从终端的键盘利用scanf函数输入数据（标准输入流）
，然后printf函数（标准输出流）打印到屏幕

               在这里，我们可以做一个类比

我们也可以利用一系列的文件操作函数，进行文件的读或写。

2.4文件名

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

3. 文件的打开和关闭

3.1 文件指针

缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
（文章第8点会介绍什么是缓冲文件系统）
每个被使用的文件都在内存中开辟了一个相应的文件信息区，
用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。
这些信息是保存在一个结构体变量中的。
该结构体类型是有系统声明的，取名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结构的变量，
这样使用起来更加方便。

      也就是说，我们的stdio.h这个头文件已经包含了文件操作的相关信息
      具体的实现细节我们不需要知道，使用者只需要知道如何进行读写即可。

FILE *pf;//我们创建一个FILE*的指针变量

定义pf是一个FILE*类型的指针变量，可以让pf指向某个文件的文件信息区
通过该文件信息区就能够访问该文件。

         也就是说，通过文件指针变量能够找到与它相关联的文件

比如：

3.2 文件的打开和关闭

正如一个水瓶一样，我们要取水和往水瓶里灌水，
第一步肯定是打开盖子
最后一步也要把盖子盖住

同理，我们要在C程序中使用文件，
第一步就要打开文件
使用结束后就是关闭文件

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

3.2.1 fopen函数

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

编写程序打开文件的时，都会返回一个FILE*的指针变量指向该文件，
也相当与建立了指针和文件的关系。
如果打开失败，会返回一个空指针NULL

const char * filename  指的是要打开的文件名
const char * mode 指的是文件打开的方式
打开方式如下 ：
（不用刻意去背，忘记的时候查文档即可）

3.2.2 fclose函数

int fclose ( FILE * stream );

成功关闭返回返回0，关闭失败返回EOF

3.2.3 利用C程序创建一个文件

#define _CRT_SECURE_NO_WARNINGS
//如果用VS运行可能报警告，把这段代码放在第一行就不会报警告了
#include 
int main()
{
	FILE* pf = fopen("test.txt", "w"); 
	//打开文件,打开方式是“w”(只写)，如果文件不存在则创建一个文件
	//返回值让pf接收，这时pf指向我们的文件信息区
	//我们可以在运行C程序的文件夹下找到这个test.txt文件
	if (NULL == pf) //养成好习惯，判断是否创建成功才继续执行下面代码
	{
		perror("fopen");
		return -1;
	}
	fclose(pf); //关闭文件
	pf = NULL;//养成好习惯，关闭文件后将指针置为NULL
	return 0;
}

在自己的文件夹下找到了我们创建的文件
创建成功！

这里的例子是相对路径
如果想在自己电脑某个盘内创建文件可以用绝对路径
例如
FILE* pf = fopen("c://test.txt", "w");

4. 文件的顺序读写

4.1 文件的顺序读写要用到的函数

所谓的“顺序”读写，就是利用文件操作函数进行读或者写的时候，
一个字符一个字符，
或者一行字符串一行字符串的读或者写，
按照顺序来，不能由第一个字符跳到第三个字符。

以下是顺序读写时要用到的函数：

上面图中，
什么是输入流？
什么是输出流？

还记得上面那两张可以类比的图吗？
我们把它加上输入流和输出流同样可以类比

            从内存里输出数据到屏幕，就是输出流，这里的printf用到的是标准输出流（stdout）
            从键盘输入数据到内存，就是输入流,这里的scanf用到的是标准输入流（stdin）

        同样地，我们可以看看类比到文件的结果
        从内存里写数据到磁盘文件里，就是输出流
        从磁盘文件里读数据到内存里，就是输入流

4.2 各种文件顺序读写输入输出函数介绍

4.2.1 字符输出函数fputc 和 字符输入函数fgetc

fputc

int fputc ( int character, FILE * stream );

这个函数的返回值是int
写入文件成功就返回写入字符的ASCII值
写入文件就失败返回EOF

形参里的 int character 指的是要输出的字符，因为字符本质上是ASCII码
所以是int类型 。
FILE * stream 指的是要输出到哪个文件指针

实例1：
#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "w"); 
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//单个字符用单引号括起来
	fputc('a', pf);//输出字符a到pf所指向的文件
	fclose(pf);
	pf = NULL;
	return 0;
}

实例2
//我们再次调用这个函数，它会自动在下一个位置输出另外一个字符
#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "w"); 
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	fputc('a', pf);
	fputc('b', pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

fgetc

int fgetc ( FILE * stream );

这个函数是读文件的内容到内存里去，
返回值是int类型
成功读取返回这个字符的ASCII
读取失败返回EOF

形参里 FILE * stream 指的是文件指针指向的文件

//实例3：我们的实例1里面文件test.txt存了一个a，
//那么我们从中读取a到内存
#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
//注意这里的文件打开方式改为“r”,表示只读
	FILE* pf = fopen("test.txt", "r"); 
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	int i = fgetc(pf);
	printf("%c", i); //a
	fclose(pf);
	pf = NULL;
	return 0;
}

4.2.2 文本行输出函数fputs 和 文本和输出函数fgets

fputs

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

这是一个可以输出字符串到文件中的函数
返回值是int
成功写到文件里面会返回一个非负的值
写入文件失败的话会返回EOF

const char * str 表示要写入的字符串
FILE * stream 表示文件指针所指向的文件

//实例4
#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "w"); 
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	fputs("abcd\n",pf); //加入\n表示换行，不然下次默认写入不会换行
	fputs("efg", pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

fgets

char * fgets ( char * str, int num, FILE * stream );

这是一个从文件中读取字符串到内存中的函数
返回值需要一个数组来接收它
读取失败的话会返回NULL

char * str 表示接收的数组
int num 表示要读取的个数
FILE * stream 表示文件指针指向的文件

//实例5：我们用实例4写入的字符串读
#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "r"); 
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	char arr[20] = { 0 };
	fgets(arr, 10, pf);
	//需要注意的是，这个函数只会一行一行地读。
	//如果想要读取下一行再次调用就可以了。
	printf("%s", arr); //abcd
	fgets(arr, 10, pf);
	printf("%s", arr);//efg
	fclose(pf);
	pf = NULL;
	return 0;
}

4.2.3 格式化输出函数fprintf和格式化输入函数fscanf

fprintf

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

前面我们讲到的是字符或者文本输出输入函数，
如果我们想把一个结构体变量的数据输出到文件中
该如何做呢？

//来看实例6：
#define _CRT_SECURE_NO_WARNINGS
#include 
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = { "zhangsan",18,95 }; //创建的结构体成员
	FILE* pf = fopen("test.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//格式化输出数据到文件里
	fprintf(pf, " %s %d %.2f", s.name, s.age, s.score);
	fclose(pf);
	pf = NULL;
	return 0;
}

这个函数是不是和printf很像？
int printf ( const char * format, ... );
int fprintf ( FILE * stream, const char * format, ... );
就是多了一个文件指针指向的文件形参

区别就是printf是将数据输出到终端，即屏幕上。
fprintf是将数据输出到文件里

fscanf

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

同样地，如果我们想把文件中的不同类型的数据读到内存的结构体里
又该如何做呢？

//我们直接来看实例7：
//文件里我们用的是实例6写的数据
#define _CRT_SECURE_NO_WARNINGS
#include 
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = { 0 };
	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", s.name, s.age, s.score);
	//zhangsan 18 95.000000
	fclose(pf);
	pf = NULL;
	return 0;
}

这个函数是不是和scanf很像？
int scanf ( const char * format, ... );
int fscanf ( FILE * stream, const char * format, ... );
只不过是形参里多了一个文件指针指向的文件形参而已

区别就是scanf是从终端键盘上输入数据到内存中
fscanf是从文件上读数据到内存中

4.2.4 二进制输出 fwrite 和 二进制输入 fread

fwrite

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

//实例8：
#define _CRT_SECURE_NO_WARNINGS
#include 
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = {"zhangsan",18,95};
	FILE* pf = fopen("test.txt", "wb");
	//打开方式改为wb，表示二进制地写
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//第一个参数指的是地址，第二个参数是大小
	//第三个参数表示存放大小为sizeof（s）的数据几组
	//第四个参数是要放到哪个文件里去
	fwrite(&s, sizeof(s), 1, pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

以二进制的形式输出到文件里我们看上去是乱码，
但是在利用fread输入到内存中时，程序可以解读出来。

fread

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

//实例9：
#define _CRT_SECURE_NO_WARNINGS
#include 
struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = {0};
	FILE* pf = fopen("test.txt", "rb");//rb表示二进制只读
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	fread(&s, sizeof(s), 1, pf);
	printf("%s %d %f", s.name, s.age, s.score);
	//zhangsan 18 95.000000
	fclose(pf);
	pf = NULL;
	return 0;
}

5. 文件的随机读写

前面我们讲，顺序读写是一个字符一个字符或者一行字符串一行字符串地读或者写，按部就班来，
不能由第一个字符直接跳到第三个字符。

那么随机读写就是，我们可以任意指定一个字符或者字符串的进行读写，比较灵活
实现的方法是根据指针的偏移量来实现

5.1 fseek 函数

seek 寻找 
file seek 就是文件寻找的意思，在这里的意思就是寻找文件指针的位置
说的官方一点就是 ：
根据文件指针的位置和偏移量来定位文件指针。

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

FILE * stream 是文件指针
offset 就是偏移量的意思
origin 源头,就是就哪里开始偏移的意思

我们来看一下最后一个参数，文档里有它的三个参数

SEEK_SET 从文件开头开始偏移
SEEK_CUR 从当前文件指针位置开始偏移
SEEK_END 从文件末尾开始偏移

什么意思呢？
我们直接来看实例10：
#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "r"); // test.txt 存放的数据是abcdef
	//现在我们想直接读到b
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//顺序读写
	//int i = fgetc(pf);//我们调用一次这个函数，文件指针就会自动指向下一位
	//printf("%c ", i);//a
	//i = fgetc(pf);
	//printf("%c ",i);//b

     //随机读写,SEEK_SET
    fseek(pf, 1, SEEK_SET);//文件指针为pf，从文件的开头开始，偏移量为1
	int i = fgetc(pf);
	printf("%c ", i);//b,这样我们就可以通过利用偏移量进行随机读写
	
	//现在的文件指针指向c
	//SEEK_CUR,从当前文件指针位置开始偏移
	fseek(pf, 2, SEEK_CUR);//偏移量为2
	i = fgetc(pf);
	printf("%c", i);//e

    //SEEK_END，从文件末尾开始偏移
    fseek(pf, -2, SEEK_END);
	i = fgetc(pf);
	printf("%c ", i);//e
	fclose(pf);
	pf = NULL;
	return 0;
}

数据是abcdef
注意这个fseek(pf,-2,SEEK_END)，
它是从文件末尾开始偏移-2
那为什么不是d,而是e?

5.2 ftell 函数

long int ftell ( FILE * stream );

这个函数顾名思义就是就是告诉你当前文件指针指向的位置
官方一点的说法就是
返回文件指针相对于起始位置的偏移量

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	int i = fgetc(pf);
	printf("%c ", i);//a，此时把指针指向b
	int j = ftell(pf);//1，此时偏移量0为a,偏移量1为b，所以返回1
	printf("%d ", j);//1
	return 0;
}

5.3 rewind 函数

void rewind ( FILE * stream );

rewind 就是重绕的意思
在C语言里面就是
让文件指针的位置回到文件的起始位置

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	int i = fgetc(pf);
	printf("%c ", i);//a，此时把指针指向b
	int j = ftell(pf);//1，此时偏移量0为a,偏移量1为b，所以返回1
	printf("%d ", j);//1

	rewind(pf);//pf重新指向文件开头
	printf("%d ", ftell(pf));0，//计算偏移量为0
	return 0;
}

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

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

来看一下测试用例：
#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
 int a = 10000;
 FILE* pf = fopen("test.txt", "wb");
 fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
 fclose(pf);
 pf = NULL;
 return 0; }

可以看到此时文本文件中是乱码的形式，因为记事本看不懂我们的二进制文件

我们在源文件里面右键，点击添加现有项，把刚才创建的文本文件添加进来

然后右键点击刚才添加的文本文件，点击打开方式，选择二进制编辑器

7. 文件读取结束的判定

7.1 被错误使用的 feof

牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。
而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。
1. 文本文件读取是否结束或者失败，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
例如：
fgetc 判断是否为 EOF .
fgets 判断返回值是否为 NULL .
fscanf 判断返回的数据是否小于格式串中指定的数据的个数
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
fread判断返回值是否小于实际要读的个数。

例子：
#define  _CRT_SECURE_NO_WARNINGS
#include 
#include 
int main() {
	int c = 0; // 注意：int，非char，要求处理EOF
	FILE* fp = fopen("test.txt", "r");
	if (NULL == fp) {
		perror("File opening failed");
		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;
}

8. 文件缓冲区

前面我们在文件信息区中讲过 “缓存文件系统” 
ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序
中每一个正在使用的文件开辟一块“文件缓冲区”。

从内存向磁盘输出数据会先送到内存中的缓冲区，
装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓
冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。
缓冲区的大小根据C编译系统决定

意思就说，不管你是从内存里输出数据到文件中，还是从文件里输入数据到内存
都要经过缓冲区，等缓冲区里的数据放满，才能传输到文件中或者内存中。
这样的话可以提高效率，避免每次传输数据都要打扰一次硬盘或内存，先把数据存储起来，
再一次性传给硬盘或者内存。

这样就有一个问题：
那既然要把缓冲区装满才能传到文件或者内存中，那如果我在一次传输中只传输了一点点大小的数据，
并没有装满，那是不是数据不能成功传输？

其实我们的fclose()函数，会自动刷新缓冲区，这样的话，不管是多小的数据，就算没有装满缓冲区，
最后也会成功传输到文件或者内存里去。
所以fopen文件后，一定要fclose，刷新缓冲区，否则可能会影响到数据的传输。

总结

这篇文章把文件操作一些基础和比较的重要的知识点总结了一遍，
如果有不对的地方，可以在评论区指出，共同学习！