掌握C语言文件操作：从入门到精通的完整指南！

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C语言学习
贝蒂的主页：Betty‘s blog

1. 什么是文件

文件其实是指一组相关数据的有序集合。这个数据集有一个名称，叫做文件名。文件通常是驻留在外部介质(如磁盘等)上的，在使用时才调入内存中来。

从文件功能上来讲，一般可分为：程序文件与数据文件

1.1 文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用，这就是文件名

• ⽂件名包含3部分：⽂件路径+⽂件名主⼲+⽂件后缀
• 例如：c:\code\test.txt

1.2 程序文件

程序文件一般指：源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）

• 源程序文件一般在创建程序目录文件下

• 源程序文件经过编译器链接与链接器链接可以生成我们的可执行程序的文件。

1.3 数据文件

⽂件的内容不⼀定是程序，⽽是程序运行时读写的数据，⽐如程序运⾏需要从中读取数据的⽂件，或者输出内容的⽂件。

本章讨论的是数据文件。

在以前各章所处理数据的输⼊输出都是以终端为对象的，即从终端的键盘输⼊数据，运⾏结果显⽰到显⽰器上。

其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使⽤，这⾥处理的就是磁盘上⽂件。

2. 文件的作用

如果没有⽂件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运⾏程序，是看不到上次程序的数据的，如果要将数据进⾏持久化的保存，我们就需要使⽤文件。

3. 文件的打开与关闭

3.1 流与标准流

(1) 流

我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输⼊输出操作各不相同，为了⽅便程序员对各种设备进⾏⽅便的操作，我们抽象出了流的概念，我们可以把流想象成流淌着字符的河。

C程序针对文件、画面、 键盘等的数据输⼊输出操作都是通过流操作的。⼀般情况下，我们要想向流⾥写数据，或者从流中读取数据，都是要打开流，然后操作。

(2) 标准流

那为什么我们从键盘输⼊数据，向屏幕上输出数据，并没有打开流呢？那是因为C语⾔程序在启动的时候，默认打开了3个流：
• stdin-标准输⼊流，在⼤多数的环境中从键盘输⼊，scanf函数就是从标准输⼊流中读取数据。
• stdout-标准输出流，⼤多数的环境中输出⾄显⽰器界⾯，printf函数就是将信息输出到标准输出流中。
• stderr-标准错误流，⼤多数环境中输出到显⽰器界⾯。

这是默认打开了这三个流，我们使⽤scanf、printf等函数就可以直接进⾏输⼊输出操作的。stdin、stdout、stderr三个流的类型是： FILE* ，通常称为文件指针。
在C语⾔中，就是通过 FILE* 的⽂件指针来维护流的各种操作的。

3.2 文件指针

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

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

例如，VS2022编译环境提供的 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* pf;//文件指针变量

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。

一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。我们来看看如何创建一个FILE的指针变量

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

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

3.3 文件的打开与关闭

⽂件在读写之前应该先打开⽂件，在使⽤结束之后应该关闭⽂件。这与我们前面学习的动态内存开辟很类似。

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

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

(1) fopen函数

1. 头文件#include<stdio.h>

2. 声明：FILE *fopen(const char *filename, const char *mode)

• filename -- 字符串，表示要打开的文件名称。

• mode -- 字符串，表示文件的访问模式。

3. 作用：使用给定的模式 mode 打开 filename 所指向的文件

4. 返回值：该函数返回一个 FILE 指针。否则返回 NULL，且设置全局变量 errno 来标识错误。

下表为常见的访问模式(mode):

(2) fclose函数

1. 头文件#include<stdio.h>

2. 声明：int fclose(FILE *stream)

   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了要被关闭的流。

3. 作用：关闭流 stream。刷新所有的缓冲区

4. 返回值：如果流成功关闭，则该方法返回零。如果失败，则返回 EOF。

下列是fopen与fclose具体使用：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}	
	//关闭文件
	fclose(pf);
	pf = NULL;		//防止野指针
	return 0;
}

4. 文件的顺序读写

4.1 单字符输入输出

(1) fputc函数

1. 头文件：#include<stdio.h>

2. 声明：int fputc(int char, FILE *stream)

   • char -- 这是要被写入的字符。该字符以其对应的 int 值进行传递。
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符的流。

3. 作用：把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中。

4. 返回值：如果没有发生错误，则返回被写入的字符。如果发生错误，则返回 EOF，并设置错误标识符。

下列是具体的fputc的使用方法：

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
    //将abc放进文件
	fputc('a', pf);
	fputc('b', pf);
	fputc('c', pf);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

如果你想查看写入结果，可以在创建项目下找到Debug文件，打开

(2) fgetc函数

1. 头文件：#include<stdio.h>

2. 声明：int fgetc(FILE *stream)

   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要在上面执行操作的流。

3. 作用：从指定的流 stream 获取下一个字符（一个无符号字符）。

4. 返回值：该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF。

下列是具体的fputc的使用方法：

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");//只读
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fputc('a', pf);
	fputc('b', pf);
	fputc('c', pf);
	int ch = fgetc(pf);
	printf("读出来的字符为：%c\n", ch);
	ch = fgetc(pf);
	printf("读出来的字符为：%c\n", ch);
	ch = fgetc(pf);
	printf("读出来的字符为：%c\n", ch);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

输出结果：

4.2 文本行输入输出

(1) fputs函数

1. 头文件：#include<stdio.h>

2. 声明：int fputs(const char *str, FILE *stream)

   • str -- 这是一个数组，包含了要写入的以空字符终止的字符序列。

   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符串的流。

3. 作用：把字符串写入到指定的流 stream 中，但不包括空字符。

4. 返回值：该函数返回一个非负值，如果发生错误则返回 EOF。

下面是fputs的具体使用方法：

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fputs("hello betty", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

演示结果：

(2) fgets函数

1. 头文件：#include<stdio.h>

2. 声明：char *fgets(char *str, int n, FILE *stream)

   • str -- 这是指向一个字符数组的指针，该数组存储了要读取的字符串。
   • n -- 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度。
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流。

3. 作用：从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

4. 返回值：如果成功，该函数返回相同的 str 参数。如果到达文件末尾或者没有读取到任何字符，str 的内容保持不变，并返回一个空指针。如果发生错误，返回一个空指针。

下面是fgets的具体使用方法：

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fputs("hello betty", pf);
	char arr[] = "##########";
	fgets(arr, 5, pf);
	puts(arr);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

输出结果：

• 虽然读取五个字符，但是只会显示四个字符，因为'\0也会默认添加进去

4.3 格式化输入输出

(1) fprintf函数

1. 头文件：#include<stdio.h>

2. 声明：int fprintf(FILE *stream, const char *format, ...)

   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
   • format -- 这是 C 字符串，包含了要被写入到流 stream 中的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。

3. 作用：按照一定格式向输出流输出数据。

4. 返回值：如果成功，则返回写入的字符总数，否则返回一个负数。

下面是fprintf的具体使用方法：

typedef struct student {
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = { "beidi", 170, 95.0 };
	//写文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fprintf(pf, "%s %d %f", s.name, s.height, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

(2) fscanf函数

1. 头文件：#include<stdio.h>
2. 声明：int fscanf(FILE *stream, const char *format, ...)
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
   • format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符和 format 说明符。
3. 作用：按照一定格式从输入流输入数据。
4. 返回值：如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

下面是fscanf的具体使用方法：

typedef struct student {
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = { "beidi", 170, 95.0 };
	//写文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fscanf(pf, "%s %d %f", s.name, &(s.height), &(s.score));
	printf("%s %d %f", s.name, s.height, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

4.4 二进制输入输出

(1) fwrite函数

1. 头文件：#include<stdio.h>
2. 声明：size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
   • ptr -- 这是指向要被写入的元素数组的指针。
   • size -- 这是要被写入的每个元素的大小，以字节为单位。
   • nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输出流。
3. 作用：把 ptr 所指向的数组中的数据写入到给定流 stream 中。
4. 返回值：如果成功，该函数返回一个 size_t 对象，表示元素的总数，该对象是一个整型数据类型。如果该数字与 nmemb 参数不同，则会显示一个错误。

下面是fwrite的具体使用方法：

typedef struct student {
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = { "beidi", 170, 95.0 };
	//写文件
	FILE* pf = fopen("test.txt", "wb");//二进制写入
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fwrite(&s, sizeof(s), 1, pf);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

• 二进制数据正常人是无法看懂的，但是电脑能准确识别

(2) fread函数

1. 头文件：#include<stdio.h>
2. 声明：size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
   • ptr -- 这是指向带有最小尺寸 size*nmemb 字节的内存块的指针。
   • size -- 这是要读取的每个元素的大小，以字节为单位。
   • nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流。
3. 作用：从给定流 stream 读取数据到 ptr 所指向的数组中
4. 返回值：成功读取的元素总数会以 size_t 对象返回，size_t 对象是一个整型数据类型。如果总数与 nmemb 参数不同，则可能发生了一个错误或者到达了文件末尾。

下面是fread的具体使用方法

typedef struct student {
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = {0};
	//写文件
	FILE* pf = fopen("test.txt", "rb");//二进制写出
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fread(&s, sizeof(s), 1, pf);
	printf("%s %d %f", s.name, s. height, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

4.5 流输入输出

从前面我们知道在我们输入输出时，默认打开**stdin - 标准输入流 **， stdout - 标准输出流， **stderr - 标准输错误 **。那我们可不可以利用流来输入输出呢？答案自然是可以的，下面是具体实例：

int main()
{
	printf("输入前：");
	int ch = fgetc(stdin);//输入
	printf("输入后：");
	fputc(ch, stdout);//输出
	return 0;
}

还有另外一种方法：

int main()
{
	printf("输入前：");
	int ch = 0;
	fscanf(stdin, "%c", &ch);
	printf("输入后：");
	fprintf(stdout, "%c", ch);
	return 0;
}

4.6 补充

(1) sprintf与sscanf

1. 头文件：#include<stdio.h>
2. 声明：int sprintf(char *str, const char *format, ...)
   • str -- 这是指向一个字符数组的指针，该数组存储了 C 字符串。
   • format -- 这是字符串，包含了要被写入到字符串 str 的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化
3. 作用：将格式化数据转换为字符串
4. 返回值：如果成功，则返回写入的字符总数，不包括字符串追加在字符串末尾的空字符。如果失败，则返回一个负数。

1. 头文件：#include<stdio.h>
2. 声明：int sscanf(const char *str, const char *format, ...)
   • str -- 这是 C 字符串，是函数检索数据的源。
   • format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符和 format 说明符。
3. 作用：将字符串按照一定格式转换为格式化数据
4. 返回值：如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

下列展示了sprintf与sscanf的具体用法：

typedef struct student {
	char name[20];
	int height;
	float score;
}stu;

int main()
{
	char buf[100] = { 0 };
	stu s = { "betty", 170, 95.0f };
	stu tmp = { 0 };
	//将这个结构体的成员转化为字符串
	sprintf(buf, "%s %d %f", s.name, s.height, s.score);
	printf("%s\n", buf);
	//将这个字符串中内容还原为一个结构体数据呢
	sscanf(buf, "%s %d %f", tmp.name, &(tmp.height), &(tmp.score));
	printf("%s %d %f", tmp.name, tmp.height, tmp.score);
	return 0;
}

(2) 对比

下表展示了scanf与printf，fscanf与fprintf，sscanf与sprintf之间的区别

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

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

1. 文本文件：以ASCII字符的形式存储的⽂件
2. 二进制文件：数据在内存中以⼆进制的形式存储的文件

⼀个数据在⽂件中是怎么存储的呢？字符⼀律以ASCII形式存储，数值型数据既可以⽤ASCII形式存储，也可以使⽤⼆进制形式存储。

如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占⽤5个字节（每个字符⼀个字节），⽽⼆进制形式输出，则在磁盘上只占4个字节。

• 字符1的二进制序列：00110001，字符0的二进制序列：00110000

测试代码：

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

• 右击源文件，添加现有项，将test.txt添加进入

• 右击test.txt文件，选择打开方式，选择二进制编辑器

• 10 27 00 00便是10000以小端存储的十六进制形式。

6. 文件的随机读写

6.1 fseek函数

1. 头文件：#include<stdio.h>
2. 声明：int fseek(FILE *stream, long int offset, int whence)
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
   • offset -- 这是相对 whence 的偏移量，以字节为单位。
   • whence -- 这是表示开始添加偏移 offset 的位置。
3. 作用：设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。
4. 返回值：如果成功，则该函数返回零，否则返回非零值。

• whence偏移offset的三种位置：

假设文件中放的是字符串“abcdef，下面是fseek的具体使用实例：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fseek(pf, 4, SEEK_SET);
	//从其实位置偏移四个字节
	int ch1 = fgetc(pf);
	printf("%c ", ch1);
	fseek(pf, -3, SEEK_END);
	//从结束位置偏移七个个字节
         int ch2 = fgetc(pf);
	printf("%c ", ch2);
	fseek(pf, 1, SEEK_CUR);
	//从当前位置偏移一个字节
	int ch3 = fgetc(pf);
	printf("%c ", ch3);
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

1. 从起始位置偏移四个字节，输出e。
2. 从末尾偏移三个字节，输出d。
3. 此时偏移指向e的位置，再偏移一个字节指向f。

6.2 ftell函数

1. 头文件：#include<stdio.h>
2. 声明：long int ftell(FILE *stream)
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
3. 作用：返回⽂件指针相对于起始位置的偏移量
4. 返回值：该函数返回位置标识符的当前值。如果发生错误，则返回 -1L，全局变量 errno 被设置为一个正值。

我们可以利用fseek和ftell来计算文件的长度(不包含'\0')，下列是代码示例

int main()
{
	FILE* pFile;
	long size;
	pFile = fopen("test.txt", "rb");
	if (pFile == NULL) 
		perror("Error opening file");
	else
	{
		fseek(pFile, 0, SEEK_END); //non-portable
		size = ftell(pFile);
		fclose(pFile);
		printf("文件长度为: %ld bytes.\n", size);
	}
	return 0;
}

6.3 rewind函数

1. 头文件：#include<stdio.h>
2. 声明：void rewind(FILE *stream)
   • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流
3. 作用：让⽂件指针的位置回到⽂件的起始位置
4. 返回值：该函数不返回任何值。

rewind常常在文件读与写同时使用时，以方便文件读取。下面是rewind的具体使用实例：

#include <stdio.h>
int main()
{
	int n;
	FILE* pFile;
	char buffer[27];
	pFile = fopen("myfile.txt", "w+");
	for (n = 'A'; n <= 'Z'; n++)
		fputc(n, pFile);//放入26个字母
	rewind(pFile);//回到起始位置，方便读取
	fread(buffer, 1, 26, pFile);//读取·
	fclose(pFile);
	buffer[26] = '\0';//字符串的结束标识
	printf(buffer);
	return 0;
}

7. ⽂件读取结束的判定

7.1 被错误使用的 feof

在我们学习C语言文件操作的过程中，常常会有人误认为feof是判断文件是否结束的函数，其实这并不准确。feof 的作⽤是：当⽂件读取结束的时候，判断是读取结束的原因是：遇到⽂件尾结束还是文件读取失败结束。

7.2 常见的结束标志

8. 文件缓冲区

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

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

我们可以利用下列代码证明缓冲区的存在：

include <stdio.h>
#include <windows.h>
//VS2019 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;
}

刷新缓冲区前：

刷新缓冲区后：

文章来源地址https://www.toymoban.com/news/detail-825077.html

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

到了这里，关于掌握C语言文件操作：从入门到精通的完整指南！的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！