「掌握C语言文件操作：基础知识和常用函数」

🌠先赞后看，不足指正!🌠

🎈这将对我有很大的帮助！🎈

📝所属专栏：C语言知识

📝阿哇旭的主页：Awas-Home page

目录

 

引言

1. 什么是文件？

 1.1 文件名

 1.2 程序文件 

 1.3 数据文件

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

 3. 文件的打开和关闭

 3.1 流和标准流

 3.1.1 流

 3.1.2 标准流

 3.2 文件指针

  3.3 文件的打开和关闭

 4. 文件的顺序读写

 4.1 字符的输入输出

 4.1.1 fputc函数

 4.1.2 fgetc函数

 4.2 文本行的输入输出

 4.2.1 fputs函数

​编辑 4.2.2 fgets函数

 4.3 格式化的输入输出

 4.3.1 fprintf函数

 4.3.2 fscanf函数

 4.4 二进制的输入输出

 4.4.1 fwrite函数

 4.4.2 fread函数

4.5 使用流来输入输出

​编辑 4.6 对比

 5. 文件的随机读取 

 5.1 fseek函数

 5.2 ftell函数 

 5.3 rewind函数

 6. 文件读取结束的判定 

 6.1 被错误使用的 feof 

 7. 文件缓冲区

 8. 结语

---

引言

        “文件”这个名词大家都不陌生，在编程领域，文件操作始终贯穿着程序开发的方方面面。在本篇博客中，我将为大家讲解C语言中文件操作的基础知识和常用函数。

        那么，话不多说，我们一起来看看吧！ 

---

1. 什么是文件？

        文件是计算机中用来存储数据的一种 数据结构，通常以特定的格式和命名方式保存在计算机的存储设备（如磁盘）中。

• 在程序设计中，文件可以分为 程序文件 和 数据文件 两种类型。

 1.1 文件名

        文件名是用来标识一个文件的名称。

        通常来说，一个文件要有自己独特的文件标识（通常由字母、数字、下划线和其他特定字符组成），以便于更容易地管理和识别。

• 文件名包含3部分：文件路径+文件名主干+文件后缀
• 例：D:\Code\2024_gitee Stash

 1.2 程序文件 

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

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

•  源程序文件经过编译、链接和加载三个步骤就会变成可执行文件。

 1.3 数据文件

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

        有时处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。

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

---

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

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

1. 文本文件：以ASCII字符的形式存储的文件。
2.  二进制文件：数据在内存中以二进制的形式存储，不加转换地输出到外存。

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

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

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

测试代码：

#include <stdio.h>
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以小端存储的十六进制形式。

---

 3. 文件的打开和关闭

 3.1 流和标准流

 3.1.1 流

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

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

 3.1.2 标准流

        那为什么我们从键盘输入数据，向屏幕上输出数据，并没有打开流呢？
        那是因为C语言程序在启动的时候，默认打开了3个流：

• stdin-标准输入流，在多数的环境中从键盘输入，scanf函数就是从标准输入流中读取数据。
• stdout-标准输出流，大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。
• stderr-标准错误流，大多数环境中输出到显示器界面。

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

 3.2 文件指针

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

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

比如，在 vs2022编译环境 提供的 stdio.h 头文件中有以下的文件类型申明：

typedef struct _iobuf FILE;
struct _iobuf {
    char* _ptr;
    int _cnt;
    char* _base;
    int _flag;
    int _file;
    int _charbuf;
    int _bufsiz;
    char* _tmpfname;
};

         不同的C语言编译器的 FILE 类型包含的内容不完全相同，但是大差不差。每当打开一个文件的时候，系统会根据文件的情况自动创建一个 FILE 结构的变量，并填充其中的信息，我们不必纠结当中的细节。一般都是通过一个 FILE 的指针来维护这个FILE结构的变量，这样使用起来更加方便。 为此我们可以创建一个 FILE* 的指针变量：

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

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

  3.3 文件的打开和关闭

        文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。这与前边的动态内存的管理有些类似。

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

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

//打开文件 
FILE* fopen(const char* filename, const char* mode);

//读取或写入文件
//。。。
//。。。

//关闭文件 
int fclose(FILE* stream);

（1）fopen 函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：FILE *fopen(const char *filename, const char *mode);

参数filename是要打开的文件的路径和名称，mode是打开文件的模式。
（3）作用：使用 mode 给定的模式打开 filename 指向文件；
（4）返回值：该函数返回一个指向FILE结构的指针，如果打开文件失败则返回NULL。使用完文件后应该使用fclose函数关闭文件。

 常用的打开文件的模式包括（粗体*为常用的模式）：

文件使用方式	含义	若指向文件不存在
“r”(只读)*	为输入数据，打开一个已经存在的文本文件	出错
“w”(只写)*	为输出数据，打开一个文本文件	建立一个新文件
“a”(追加)*	向文本文件尾添加数据	建立一个新文件
“rb”(只读)*	为输入数据，打开一个二进制文件	出错
“wb”(只写)*	为输出数据，打开一个二进制文件	建立一个新文件
“ab”(追加)*	向一个二进制文件尾添加数据	建立一个新文件
“r+”(读写)	为读和写，打开一个文本文件	出错
“w+”(读写)	为读和写，建立一个新的文件	建立一个新文件
“a+”(读写)	打开一个文件，在文件尾进行读写	建立一个新文件
“rb+”(读写)	为读和写打开一个二进制文件	出错
“wb+”(读写)	为读和写，新建一个新的二进制文件	建立一个新文件
“ab+”(读写)	打开一个二进制文件，在文件尾进行读和写	建立一个新文件

（2） fclose 函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：int fclose(FILE *stream);

参数 stream 是指向 FILE 结构的指针，它指向要关闭的文件。
（3）作用：用于关闭一个已打开的文件；
（4）返回值：fclose 函数返回一个整型值，用于表示关闭文件的成功与否。如果成功关闭文件，则返回 0；否则返回 EOF。

应用代码示例：

#include <stdio.h>

int main()
{
    //打开文件
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
        perror("fopen");
        return 1;
    }

    //关闭文件
    fclose(pf);
    pf = NULL; //避免野指针出现

    return 0;
}

---

 4. 文件的顺序读写

 4.1 字符的输入输出

 4.1.1 fputc函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：int fputc(int character, FILE *stream);

• characte 是要写入文件的字符，stream 是指向要写入的文件的指针。

（3）作用：用于将一个字符写入文件；
（4）返回值：数返回写入成功的字符，如果发生错误则返回EOF。

 测试代码：

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

 4.1.2 fgetc函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：int fgetc(FILE *stream);

• stream 是一个指向 FILE 结构的指针，指向要从中读取字符的文件。

（3）作用：用于从文件中读取一个字符，并返回读取的字符。
（4）返回值：

• 如果成功读取一个字符，则返回该字符的 ASCII 值（0-255）。
• 如果到达文件末尾或发生错误，则返回 EOF（-1）。

测试代码：

#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);
	ch = fgetc(pf);
	printf("读出来的字符为：%c\n", ch);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

 4.2 文本行的输入输出

 4.2.1 fputs函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：int fputs(const char *str, FILE *stream);

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

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

（3）作用：将字符串写入到指定的流 stream 中，但不包括空字符。
（4）返回值：函数返回非负值表示写入成功，如果发生错误则返回EOF。

 测试代码：

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

 4.2.2 fgets函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：char *fgets(char *str, int n, FILE *stream);

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

（3）作用：从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。
（4）返回值：函数返回读取成功的字符串，如果发生错误或者到达文件末尾则返回NULL。

  测试代码：

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");//只读
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fputs("Hello World! ", pf);
	char arr[] = "*************";
	fgets(arr, 4, pf);
	puts(arr);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

        从上面我们可以知道，我们读取了4个字符，但只显示了3个字符，这是为什么呢？

        通过调试，监视窗口我们可以看到， 我们读取4个字符，系统会默认将 '\0' 也添加进去。

 4.3 格式化的输入输出

 4.3.1 fprintf函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：int fprintf(FILE *stream, const char *format, ...);

• stream 是指向要读取的文件的指针。
• format是格式控制字符串，用于指定要读取的数据类型和格式。
• ...表示可变参数，用于接收读取到的数据。

（3）作用：用于将格式化数据写入文件;
（4）返回值：如果成功，则返回写入的字符总数，否则返回一个负数。

  测试代码：

#include<stdio.h>
typedef struct student 
{
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = { "awas-x", 175, 59 };
	//写文件
	FILE* pf = fopen("test.txt", "w");//只写
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fprintf(pf, "%s %d %.2f", s.name, s.height, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

 4.3.2 fscanf函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：int fscanf(FILE *stream, const char *format, ...);

• stream 是指向要读取的文件的指针。
• format是格式控制字符串，用于指定要读取的数据类型和格式。
• ...表示可变参数，用于接收读取到的数据。

（3）作用：用于从文件中按照指定格式读取数据;
（4）返回值：如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

   测试代码：

#include<stdio.h>
typedef struct student 
{
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = { "awas-x", 175, 59 };
	//写文件
	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\n", s.name, s.height, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}r

 4.4 二进制的输入输出

 4.4.1 fwrite函数

（1）头文件：在标头<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）返回值：函数返回实际写入的数据项数量，如果返回值与nmemb不相等，则表示写入过程中出现了错误。

    测试代码：

#include<stdio.h>
typedef struct student 
{
	char name[20];
	int height;
	float score;
}stu;
int main()
{
	stu s = { "awas-x", 175, 59 };
	//写文件
	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;
}

         对于二进制的数据，我们不能看懂，但电脑可以精准的识别。

 4.4.2 fread函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

• ptr – 这是指向要被写入的元素数组的指针。
• size – 这是要被写入的每个元素的大小，以字节为单位。
• nmemb – 这是元素的个数，每个元素的大小为 size 字节。
• stream – 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输出流。

（3）作用：从给定流 stream 读取数据到 ptr 所指向的数组中。
（4）返回值：函数返回实际读取的数据项数量，如果返回值与nmemb不相等，则表示读取过程中出现了错误。

 测试代码：

#include<stdio.h>
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 使用流来输入输出

         在前面我们知道，C语言输入输出默认打开 stdin-标准输入流、stdout-标准输出流、stderr-标准错误流。当然，我们也可以使用流来输入输出。

测试代码：

//方法一：
#include<stdio.h>
int main()
{
	printf("输入前:");
	int ch = fgetc(stdin);// 输入
	printf("输入后:");
	fputc(ch, stdout);// 输出
	return 0;
}


//方法二：
#include<stdio.h>
int main()
{
	int ch = 0;
	printf("输入前:");
	fscanf(stdin, "%c", &ch);// 输入
	printf("输入后:");
	fprintf(stdout, "%c", ch);// 输出
	return 0;
}

 4.6 读写函数的对比

（1）scanf/fscanf/sscanf：

• scanf: 从标准输入流中读取输入并将其存储到指定的变量中。
• fscanf: 从指定的文件流中读取输入并将其存储到指定的变量中。
• sscanf: 从指定的字符串中读取输入并将其存储到指定的变量中。

（2）printf/fprintf/sprintf：

• printf: 将格式化的输出发送到标准输出流（屏幕）。
• fprintf: 将格式化的输出发送到指定的文件流。
• sprintf: 将格式化的输出存储到一个字符串中，而不是发送到流中。

---

5. 文件的随机读写

 5.1 fseek函数

（1）头文件：在标头<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）返回值：函数的返回值为0表示移动成功，非0表示移动失败。

• whence的取值可以是以下三种：

1. SEEK_SET：从文件起始位置开始计算偏移量。
2. SEEK_CUR：从当前位置开始计算偏移量。
3. SEEK_END：从文件末尾位置开始计算偏移量。

示例代码：文件中存有字符串 " abcdef "

#include <stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror(" fopen fail");
		return 1;
	}
	fseek(pf, 2, SEEK_SET);
	//从起始位置偏移两个字节
	int ch1 = fgetc(pf);
	printf("%c ", ch1);// c
	fseek(pf, -3, SEEK_END);
	//从结束位置偏移三个字节
	int ch2 = fgetc(pf);
	printf("%c ", ch2);// d
	fseek(pf, 1, SEEK_CUR);
	//从当前位置偏移一个字节
	int ch3 = fgetc(pf);
	printf("%c ", ch3);// f
	//关闭文件
	fclose(pf);
	pf = NULL;//防止野指针
	return 0;
}

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

 5.2 ftell函数 

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：long int ftell(FILE *stream);

• stream – 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

（3）作用：用于获取文件指针当前位置的函数，返回当前文件指针的位置；
（4）返回值：该函数返回位置标识符的当前值。如果发生错误，则返回 -1，全局变量 errno 被设置为一个正值。

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

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

 5.3 rewind函数

（1）头文件：在标头<stdio.h>中定义；

（2）函数原型：void rewind(FILE *stream);

• stream – 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

（3）作用：将文件指针重新定位到文件的起始位置；
（4）返回值：无返回值。

•  rewind 函数通常在文件同时进行读与写的操作时使用，示例代码：

#include <stdio.h>
int main()
{
	int n;
	FILE* pf = fopen("test.txt", "w+");
	char buffer[27];

	for (n = 'A'; n <= 'Z'; n++)
	{
		fputc(n, pf);// 将字母'A'到'Z'写入文件
	}
	rewind(pf);// 将文件指针重新定位到文件开头

	fread(buffer, 1, 26, pf);// 从文件中读取26个字节到buffer中
	fclose(pf);
	pf = NULL;

	buffer[26] = '\0'; // 在buffer末尾添加字符串结束符'\0'
	printf(buffer);// 输出buffer中的内容
	return 0;
}

---

6. 文件读取结束的判定 

 6.1 被错误使用的 feof 

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

---

7. 文件缓冲区

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

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

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

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

 缓冲区刷新前：

 缓冲区刷新后：

在这里，我们可以知道：

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

---

 8. 结语

        希望这篇文章对大家有所帮助，如果你有任何问题和建议，欢迎在评论区留言，这将对我有很大的帮助。

        完结！咻~