【C语言】文件详细解读与操作（万字解读！！）

前言：为什么使用文件

我们前面有学过结构体，写了通讯录的程序，但是只是简单的实现了通讯录的功能。当通讯录运行起来的时候，可以给通讯录添加、删除数据，但此时的数据是存放在内存中的，当程序退出的时候，刚刚的数据自然就不复存在了。等下次运行程序时，又需要重新录入数据，显然这样的效果不是我们想要的。
我们在想既然是通讯录就应该能把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。这就涉及到了数据持久化的问题，我们使用文件可以将数据直接存放到电脑的硬盘上，从而实现数据的持久化。
本篇文章将解读C语言中的文件操作。通过简洁高效的代码，为读者提供一个清晰明了的讲解，让我们开始吧！！

---

1.什么是文件

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

1.1程序文件

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

1.2数据文件

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

本文讨论的是数据文件。

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

1.3文件名

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

例如：c:\code\test.txt
为了方便起见，文件标识常被称为文件名。

2.文件的打开与关闭

2.1文件指针

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

例如，VS2013编译环境（不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异）提供的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*的指针变量:

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

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

就像这样：

2.2文件的打开与关闭

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

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

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

该函数返回值是文件指针，通过自行定义的文件指针接收。

fopen的打开方式（mode）如下:

注意！使用的是双引号“”，同时每次使用时注意判断文件指针是否为NULL

实例如下：

#define  _CRT_SECURE_NO_WARNINGS 1 

#include

int main()
{
	FILE* pfile;
	//打开文件
	pfile = fopen("myfile.txt", "w");
	//指针内容判断
	if (pfile == NULL)
	{
		perror("fopen");
		return 1;
	}
	//文件操作
	//{...};
	//关闭文件
	fclose(pfile);
	pfile = NULL;
	return 0;
}

2.2.1文件路径

文件路径分为绝对路径与相对路径两种。

//文件路径分为两种：
//相对路径
//. 表示当前路径    .. 表示上一级路径
//绝对路径
int main()
{
	//打开文件
	FILE* pf = fopen(".\..\\..\\data.txt", "r");//相对路径
	FILE* pf = fopen("D:\\code\\data.txt", "r");//绝对路径
	return 0;	
}

3.文件的顺序读写

分类如下：

3.1数据流的概念简述

数据流是一个非常抽象的概念，我们运用到的各种数据，它会传输给外部设备，比如在屏幕显示，存到硬盘上，传到网络上等等，传输中数据就会像水流一样在中间流淌，所以叫做数据流，上图的输入输出流也属于数据流。

3.2字符输入/输出函数 fgetc/fputc

注意！！
我们下面讲的输入和输出指的是以操作系统内存为主体，外部数据存入内存叫输入，内存数据取出到系统外叫输出，不要搞混淆了哦！！
而且在输入和输出时fopen的类型要正确对应！！！

3.2.1字符输出函数fputc

参数1是单个整型，即要输出到文件的内容
参数2是目标文件指针

看上去还是很好理解的，实例如下：

//fputc实践
#include
int main()
{
	FILE* pf;
	pf = fopen("myfile.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fputc('a', pf);
	fputc('b', pf);
	fputc('c', pf);
	fputc('d', pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

3.2.2字符输入函数fgetc

fgetc函数很好理解，它是从目标指针文件中获得数据。

注意以下几点：

1. 该函数会返回当前所指向的内容，有点像文档光标，注意多次使用该函数时不会得到同一个值。
2. 如果读取到目标文件最后一个数据，就返回EOF。
3. 如果读取出现错误，同样返回EOF，并报错。

实例如下：

//fgetc实践
#include
int main()
{
	FILE* pf;
	pf = fopen("myfile.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int ca = 0;
	ca = fgetc(pf);
	printf("%c ", ca);

	ca = fgetc(pf);
	printf("%c ", ca);

	ca = fgetc(pf);
	printf("%c ", ca);

	ca = fgetc(pf);
	printf("%c ", ca);
	return 0;
}

结果如下：

3.3文本行输入/输出函数 fgets/fputs

3.3.1文本行输出函数fputs

fputs函数和fputc函数类似，只有第一个参数不同，参数传递的是字符串的首字符指针，函数作用即输出字符串到目标文件中。

实例如下：

//fputs实践
#include
int main()
{
	FILE* pf;
	pf = fopen("myfile.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fputs("abcdef", pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

文件内容如下：

3.3.2文本行输入函数fgets

fgets() 函数用来从指定文件中读取一个字符串（即遇到‘\n’就返回），并保存到数组中。
str 为字符数组首字符指针，n 为读取的字符个数，stream 为文件指针。

实例如下：

//fputs实践
#include
int main()
{
	FILE* pf;
	pf = fopen("myfile.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	char arr[50] = {0};
	fgets(arr,50,pf);
	printf("%s", arr);

	fgets(arr, 50, pf);
	printf("%s", arr);

	fclose(pf);
	pf = NULL;

	printf("\n\n别忘了点赞三连支持欧o(>ω< )o！！!\n");
	printf("(深情)\n");
	return 0;
}

结果如下：

3.4格式化输入/输出函数 fscanf/fprintf

3.4.1格式化输出函数 fprintf

除了这个文件指针，后面这个看的不是很懂，拿printf函数来对比一下：

很显然，这个fprintf和printf用法是差不多的，只是会输出保存到目标文件中，在printf函数的基础上多加一个文件指针就可以了。

实例如下：

//fprintf实践
struct S
{
	float f;
	char c;
	int n;
};

int main()
{
	struct S s = { 3.14f, 'w', 100 };

	FILE* pf = fopen("myfile.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fprintf(pf, "%f-%c-%d", s.f, s.c, s.n);

	fclose(pf);
	pf = NULL;

	return 0;
}

结果如下：

3.4.2格式化输入函数 fscanf

很显然，这个和上面的fprintf是一个道理，是在scanf基础上改为从目标文件中获取数据然后格式化保存在内存中。
要注意使用时类型要与目标文件数据类型相符合。

实例如下：

//fscanf实践
struct S
{
	float f;
	char c;
	int n;
};

int main()
{
	struct S s = {0};

	FILE* pf = fopen("myfile.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	fscanf(pf, "%f-%c-%d", &(s.f), &(s.c), &(s.n));
	printf("%f-%c-%d\n", s.f, s.c, s.n);

	fclose(pf);
	pf = NULL;

	return 0;
}

结果如下：

3.5二进制输入/输出函数fread/fwrite

注意使用该类函数时fopen的类型得对应正确，分别为‘rb’、‘wb’.

3.5.1二进制输出函数fwrite

fwrite函数有不少的参数，我们一个个分析解释：

ptr ： 指的是数组首元素指针
size：数组中一个元素的字节大小
count : 数组中的元素个数
stream：目标文件指针

这样解读我们就知道了，函数fwrite能实现将数组中的一整块元素内容写入目标文件中的功能，同时能控制写入内容的多少。

实践试试，实例如下：

#include
int main()
{
	FILE* pf = fopen("myfile.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int arr[10] = {1,2,3,4,5,6,7,8,9,0};
	fwrite(arr, sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
	fclose(pf);
	pf = NULL;

	return 0;
}

结果如下：

这怎么成功了但是是一堆问号呢？
我们回来看这个函数的名字，它叫做二进制输出函数，也就是说输进文件的内容是二进制的形式，具体我们看不明白，但是！但是没有关系，内容是没问题的，只要计算机看得懂就行。
具体到底对不对（其实是对的，没有问题），我们可以试试接下来输入时能否将原内容还原回来即可！

3.5.2二进制输入函数fread

函数fread的参数和fwrite完全一致，功能是从文件读取一整块数据存放到数组中。
当然，是用二进制方式。

实例如下：

//fread实践
#include
int main()
{
	FILE* pf = fopen("myfile.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int arr[10] = { 0 };
	fread(arr, sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	fclose(pf);
	pf = NULL;

	return 0;
}

读的就是上面保存的内容，结果如下：

完美！是计算机能读懂的东西，欸嘿嘿^^。

4.文件的随机读写

这个东西也不是很难，随机读写可不是随便乱写啊，而是我想写哪就写哪，想怎么写就怎么写XD。

4.1 fseek

fseek函数功能是：根据文件指针的位置和偏移量来定位文件指针。
先解释一下各个参数的含义：

stream：目标文件指针
offset：文件指针偏移量
origin：文件指针初始情况

第一二个比较好理解，第三个参数origin需要好好解释一下。C语言编译库中针对该参数设有三种情况：

SEEK_SET:文件起始位置
SEEK_CUR:文件当前位置（前面我们知道使用相关函数光标会记住位置）
SEEK_END:文件结束位置

通过解释我们知道origin是用来设置当前光标的起始位置的，在此基础上通过offset参数实现偏移，也就是我们说的”想去哪就去哪。“

实例如下：
我们先通过fpetc函数输入一些数据看看。

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

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	ch = fgetc(pf);
	printf("%c\n", ch);//d

	ch = fgetc(pf);
	printf("%c\n", ch);//e
	
	

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

结果如下：

我们可以看到输入了a~e的值，当前光标位置到了e，但是现在我想让它到d之后通过函数fseek从当前位置（SEEK_CUR）回到起始位置，那么我们应该设置偏移量为-4，实例如下：

#include
int main()
{
	FILE* pf = fopen("myfile.txt", "r");
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	//读文件
	int ch = fgetc(pf);
	printf("%c\n", ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	ch = fgetc(pf);
	printf("%c\n", ch);//d

	//ch = fgetc(pf);
	//printf("%c\n", ch);//e
	fseek(pf, -4, SEEK_CUR);
	ch = fgetc(pf);
	printf("%c\n", ch);//a

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

结果如下：

完美~

这两句也可以实现同样的效果，具体内容可以自行实践：

fseek(pf, 0, SEEK_SET);
fseek(pf, -9, SEEK_END);

当然你需要了解你的目标文件内容，控制好偏移量。

4.2 ftell

函数ftell的功能：返回文件指针相对于起始位置的偏移量。

直接用上面的代码试试，实例如下：

#include
int main()
{
	FILE* pf = fopen("myfile.txt", "r");
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	//读文件
	int ch = fgetc(pf);
	printf("%c\n", ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	ch = fgetc(pf);
	printf("%c\n", ch);//d

	int pos = ftell(pf);//返回偏移量
	printf("%d\n", pos);

	//ch = fgetc(pf);
	//printf("%c\n", ch);//e
	fseek(pf, -4, SEEK_CUR);
	ch = fgetc(pf);
	printf("%c\n", ch);//a

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

结果如下：

结果很满意~

4.3 rewind

rewind函数的功能：让文件指针的位置回到文件的起始位置。

继续使用上面的思路，代码如下：

#include
int main()
{
	FILE* pf = fopen("myfile.txt", "r");
	if (pf == NULL) {
		perror("fopen");
		return 1;
	}
	//读文件
	int ch = fgetc(pf);
	printf("%c\n", ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	ch = fgetc(pf);
	printf("%c\n", ch);//d

	int pos = ftell(pf);
	printf("%d\n", pos);

	//ch = fgetc(pf);
	//printf("%c\n", ch);//e
	//fseek(pf, -4, SEEK_CUR);
	rewind(pf);
	ch = fgetc(pf);
	printf("%c\n", ch);

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

结果如下：

同样完美实现效果~~^^

5.文本文件和二进制操作

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

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

那么一个数据是怎么在内存中存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

举个栗子：
如有整数10000，如果以ASCII码值输出到磁盘，则会在磁盘中占用5个字节（每一个字符占一个字节）。而如果用二进制形式输出，则在磁盘上只占4个字节。（VS2022测试）

这里分享一个查看二进制内容的方法：
①

②

③

④
结果如下：

测试代码如下：

#define  _CRT_SECURE_NO_WARNINGS 1 

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

6.文件读取结束的判定

6.1 被错误使用的feof函数

牢记！在文件读取的过程中，不能用feof函数的返回值直接来判断文件的是否结束。

而是应用于当文件读取结束时，判断是读取失败结束，还是遇到文件尾结束。

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

正确的使用：
文本文件的栗子：

//文本文件检查是否结束
#include 
#include 
int main(void)
{
    int c; // 注意：int，非char，要求处理EOF
    FILE* fp = fopen("test.txt", "r");
    if (!fp) 
    {
        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);
    return 0;
}

二进制文件的栗子：

#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);
}

7.文件缓冲区

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

这样在内存单独找一块空间作缓冲区能使程序更高效率运行，避免多次重复。

我们也可以来验证一下这种”缓冲区“是否真的存在，代码如下：

include <stdio.h>
#include 
//VS2022 WIN11环境测试
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;
}

效果如下：

那么我们这里可以得出一个结论：

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

---

结语

好了以上就是本篇“【C语言】文件详细解读与操作”博客的全部内容啦，感谢各位的阅读=v=，如有不足之处欢迎在评论区指出哦！！
觉得可以的话别忘了点赞三连支持一下欧！拜托啦这对我真的很重要o(>ω< )o！！!