C语言中的文件操作及其函数应用介绍

本章重点

• 为什么使用文件
• 什么是文件
• 文件的打开和关闭
• 文件的顺序读写
• 文件的随机读写
• 文本文件和二进制文件
• 文件读取结束的判定
• 文件缓冲区 正文开始

---

1. 为什么使用文件

我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯 录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。

我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。 这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

---

2. 什么是文件

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

---

2.1 程序文件

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

---

2.2 数据文件

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

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

---

2.3 文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。 文件名包含3部分：文件路径+文件名主干+文件后缀 例如： c:\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; //FILE为系统声明的结构体类型

意思就相当于，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);
//返回一个FILE类型的指针，两个参数分别为：(文件名，使用文件的方式)

//关闭文件
int fclose(FILE* stream);
//返回一个整型数据，参数为一个待关闭的文件指针

打开方式如下：

示例代码：

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    FILE* pFile;
    pFile = fopen("myfile.txt", "w");//仅”写"文件
    //文件操作
    if (pFile != NULL)
    {
        perror("pFile");
    }
    fclose(pFile);    //关闭文件
    pFile = NULL;

    return 0;
}

输出结果：

---

4. 文件的顺序读写

因为我们写程序时是在内存中写的，而文件又在硬盘上，当我们把文件里的数据读到内存中去的动作叫做输入(读取)，把程序中的数据写到文件里面或者放到硬盘上的动作叫做写入(输出)。

下图为在我们读写文件时会用到的各种函数

---

4.1 fputc字符输出函数

写入文件,例如向文件中输入一些字符：

fputc函数为向指定的文件中输入一个字符,第一个参数为输入的字符,第二个参数为文件指针,返回值为字符的ASCLL值。

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    FILE* pf;
    pf = fopen("E:\\test\\test2.23.txt", "w");//仅“写"文件
    //文件操作
    if (pf == NULL)
    {
        perror("pf");
        return 1;
    }
    //写文件
    fputc('b', pf);
    fputc('i', pf);
    fputc('t', pf);
    
    fclose(pf);    //关闭文件
    pf = NULL;

    return 0;
}

'b''i''t'写入文件时,也是按照顺序来写入的,因此叫做文件的顺序读写. 当fputc消失时,输入文件里的值也会消失:

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    FILE* pf;
    pf = fopen("E:\\test\\test2.23.txt", "w");//仅”写"文件
    //文件操作
    if (pf == NULL)
    {
        perror("pf");
        return 1;
    }
    //写文件
    //fputc('b', pf);
    //fputc('i', pf);
    //fputc('t', pf);

    fclose(pf);    //关闭文件
    pf = NULL;

    return 0;
}

可以看到文件的大小又变为了0KB

---

4.2 fgetc字符输入函数

读取文件,例如读取文件中的字符数据:

fgetc函数为从指定的文件中读取一个字符,若读取正常,则会返回字符的ASCLL值,若读取失败,则会返回EOF(符号常量,其值为-1),fgetc每使用一次,文件的位置指针就会自动向后移动一位。

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    FILE* pf;
    pf = fopen("E:\\test\\test2.23.txt", "r");//仅“读"文件
    //打开文件,"r"为仅读取
    if (pf == NULL)
    {
        perror("pf");
        return 1;
    }
    //写文件
    int ret = fgetc(pf);//一次
    //从文件中读取一个字符
    printf("%c\n", ret);
    //打印读取的字符
    ret = fgetc(pf);   //两次
    printf("%c\n", ret);
    ret = fgetc(pf);   //三次
    printf("%c\n", ret);
    //每读取完一个字符后，再读取时自动读取下一个字符

    fclose(pf);    //关闭文件
    pf = NULL;

    return 0;
}

文件内容:

输出结果:

当fgetc读取完毕或者读取错误时则会返回EOF(-1):

---

4.3 fputs文本行输出函数

按行输入文件:

fputs为向指定的文件中写入字符串,不自动写入字符串结束标记符‘\0’。 成功写入一个字符串后，文件的位置指针会自动后移，函数返回值为 非负整数 ；输入错误则返回 EOF (符号常量，其值为-1)

注:换行要体现在代码中

按行输入时无换行符\n:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    FILE* pf;
    pf=fopen("E:\\test\\test2.23.txt", "w");//仅”写"文件
    //写文件--按行来写
    if (pf == NULL)
    {
        perror("pf");//若pf为空指针，则输出错误原因
        return 1;
    }
    fputs("abcdef", pf);//注意：换行的话要体现在代码中
    fputs("ghijkllmn", pf);

    fclose(pf);
    pf = NULL;

    return 0;
}

文件中的内容: 按行输入时有换行符\n:

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    FILE* pf;
    pf=fopen("E:\\test\\test2.23.txt", "w");//仅“写"文件
    //写文件--按行来写
    if (pf == NULL)
    {
        perror("pf");//若pf为空指针，则输出错误原因
        return 1;
    }
    fputs("abcdef\n", pf);//注意：换行的话要体现在代码中
    fputs("ghijkllmn", pf);

    fclose(pf);
    pf = NULL;

    return 0;
}

文件中的内容:

---

4.4 fgets文本行输入函数

按行读取文件:

fgets函数的作用是从指定的文件中读取num个字符，num是最多能读取的字符个数，但是真正读取到的字符个数为num-1，因为最后要留一个位置给'\0'，最后读取到的内容会存储到字符指针变量str所指向的内存空间中。

示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    char str[50] = { 0 };
    FILE* pf;
    pf=fopen("E:\\test\\test2.23.txt", "r");//仅”读"文件
    //读取文件
    if (pf == NULL)
    {
        perror("pf");//若pf为空指针，则输出错误原因
        return 1;
    }
    fgets(str, 5, pf);//只读取4个字符的内容
    printf("%s\n", str);

    fgets(str, 3, pf);//只读取2个字符的内容
    printf("%s\n", str);

    fclose(pf);
    pf = NULL;

    return 0;
}

文件内容：

输出结果： 为了弄清fgets函数的原理，我们在文件内容不变的基础上将代码做了一些修改：

//输出结果是什么？
#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include <stdio.h>
int main()
{
    char str[50] ="xxxxxxxxxxxxxxxxxxxxxxx";
    FILE* pf;
    pf=fopen("E:\\test\\test2.23.txt", "r");//仅“读"文件
    //读取文件
    if (pf == NULL)
    {
        perror("pf");//若pf为空指针，则输出错误原因
        return 1;
    }
    fgets(str, 5, pf);//只读取4个字符的内容
    printf("%s\n", str);

    fgets(str, 1, pf);//读取的内容是什么？
    printf("%s\n", str);

    fgets(str, 8, pf);
    printf("%s\n", str);

    fclose(pf);
    pf = NULL;

    return 0;
}

输出结果： 开始调试：

fgets第一次使用时： fgets第二次使用时： fgets第三次使用时：

通过str字符数组的内容的变化情况，我们可以得知，fgets函数在使用时，会把读到的字符数存储到我们所创建的字符数组中去, 而且会在末尾带上一个'\0', 不仅如此，后一次读取的内容在存储时会将前一次读取的内容从第一个字符开始覆盖掉, 当fgets中的参数num为1时，就会将\0存储在字符数组中，因此在我们输出在屏幕上时就会什么内容都没有; 当num为0时，不会将任何内容存储在字符数组中。

---

4.5 fprintf格式化输出函数

format表示格式(%s、%d等等)，后面的"..."表示可变参数(一个或者多个参数，参数的个数可以变化)，fprintf和printf相比只是多了一个FILE*stream而已。

示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include<stdio.h>
typedef struct Student
{
	char Name[20];     //姓名
	int Age;                 //年龄
	float High;            //身高
}S;

int main()
{
	S s = { "张三",18,177.5f };
	FILE* pf = fopen("E:\\test\\test2.23.txt", "w");//仅”写"文件
	//对格式化的内容进行读取(输入)文件
	if (pf == NULL)
	{
		perror("pf");
		return 1;//函数非正常终止
	}
	fprintf(pf, "%s  %d  %f", s.Name, s.Age, s.High);

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

输出结果：

文件内容：

---

4.6 fscanf格式化输入函数

跟fprintf一样，format表示格式(%s、%d等等)，后面的"..."表示可变参数(一个或者多个参数，参数的个数可以变化),fscanf和scanf相比也只是多了一个FILE*stream而已。

示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include<stdio.h>
typedef struct Student
{
	char Name[20];     //姓名
	int Age;                 //年龄
	float High;            //身高
}S;

int main()
{
	S s = { 0 };
	FILE* pf = fopen("E:\\test\\test2.23.txt", "r");//仅"读"文件
	//对格式化的内容进行读取(输入)文件
	if (pf == NULL)
	{
		perror("pf");
		return 1;//函数非正常终止
	}

	fscanf(pf, "%s%d%f", s.Name, &(s.Age), &(s.High));
	//读取的内容就相当于在屏幕上输入的内容
	printf("%s    %d    %f", s.Name, s.Age, s.High);
	//输出读取的内容

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

文件内容：

输出结果：

---

4.7 fwrite、fread二进制输出、输入函数

fwrite的作用是写内容到指定文件中去，void* buffer的意思是指向所写内容的指针，size_t size表示要写的内容有多少字节,size_t count表示要写入的以上一个参数为单位的元素个数，FILE* stream表示文件指针，返回值是表示读取元素的个数。

fread的作用是读取指定文件里的内容，且第一个参数ptr表示盛放内容的首地址. 第二个参数size表示每个元素的大小，单位还是字节. 第三个参数表示要读取的元素个数. 第四个参数stream表示的是文件指针，即从哪个文件中读取. 返回值则是表示读取元素的个数。

示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include<stdio.h>
typedef struct Student
{
	char Name[20];         //姓名
	int Age;              //年龄
	float High;          //身高
}S;

int main()
{
	S s = {"张三",18,177.5};
	FILE* pf;
	pf = fopen("E:\\test\\test2.23.txt", "w");//仅"写"文件
	if (pf == NULL)
	{
		perror("pf");
		return 1;
	}
	fwrite(&s, sizeof(s), 1, pf);
	

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

文件内容： 这是啥？此时我们发现文件中的部分内容我们并不认识，甚至可以说是一串乱码，但是我们如果用fread函数来读取的话，是否能够读出来我们原本想写入的数呢？

示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#define _CRT_SECURE_NO_WARNINGS
/* fopen fclose example */
#include<stdio.h>
typedef struct Student
{
	char Name[20];        //姓名
	int Age;              //年龄
	float High;           //身高
}S;

int main()
{
	S s = {0};
	FILE* pf;
	pf = fopen("E:\\test\\test2.23.txt", "r");//仅"读"文件
	if (pf == NULL)
	{
		perror("pf");
		return 1;
	}

	fread(&s, sizeof(s), 1, pf);//读取文件
	printf("%s  %d  %f", s.Name, s.Age, s.High);

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

文件内容： 输出结果： 由此可见，fread和fwrite函数平常应该放在一起使用。

---

4.8 对比一组函数

1. scanf / fscanf / sscanf

2. printf / fprintf / sprintf

scanf--针对标准输入的格式化的输入语句--stdin

fscanf--针对所有输入流的格式化的输入语句--stdin/文件

sscanf--对一个字符串读出格式化的数据

参数str为要读取数据的字符串；format为用户指定的格式；"..."为变量，用来保存读取到的数据。【返回值】成功则返回参数数目，失败则返回-1。

printf--针对标准输出的格式化输出语句--stdout

fprintf--针对所有输出流的格式化输出语句-stdout/文件

sprintf--把一个格式化的数据转化为字符串

跟sscanf一样，参数str为要读取数据的字符串；format为用户指定的格式；"..."为变量，用来保存读取到的数据。【返回值】成功则返回参数数目，失败则返回-1。

sprintf示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
typedef struct Student
{
	char Name[15];//姓名
	int Age;            //年龄
	float High;       //身高
}S;

int main()
{
	S s = { "张三",18,177.5 };
	char buf[100] = { 0 };
	sprintf(buf, "%s  %d  %f", s.Name, s.Age, s.High);
	//sprintf(将s内的数据整合成字符串并存到buf字符数组中，格式，指定的数据)；
	printf("%s\n", buf);
	//打印 buf 字符数组的内容，s内的内容将直接作为字符串打印出来

	return 0;
}

输出结果：

那么如何将这个字符串数据还原呢？

sscanf示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
typedef struct Student
{
	char Name[15];//姓名
	int Age;            //年龄
	float High;       //身高
}S;

int main()
{
	S s = { "张三",18,177.5 };
	char buf[100] = { 0 };
	S tmp = { 0 };

	sprintf(buf, "%s  %d  %f", s.Name, s.Age, s.High);
	//sprintf--将格式化的数据转化为字符串
	//sprintf(将s内的数据整合成字符串并存到buf字符数组中，格式，指定的数据)；
	printf("%s\n", buf);

	//打印buf字符数组的内容，s内的内容将直接作为字符串打印出来
	sscanf(buf, "%s  %d   %f", tmp.Name, &(tmp.Age), &(tmp.High));
	//sscanf-从字符串中读取格式话数据
	printf("%s  %d  %f\n", tmp.Name, tmp.Age, tmp.High);
	//打印读取的数据

	return 0;
}

输出结果：

---

5. 文件的随机读写

在前面的学习中，我们知道那些定位文件的指针在时刻发生变化，比如说在你读取一次以后就会自动指向下一个要读取的内容，这样的方式有一定的局限性，没办法让我们想读哪儿就读哪儿，那么有没有什么局限性更小的方法呢？接下来我们就来看看文件的随机读写。

---

5.1 fseek

fseek：根据文件指针的位置和偏移量来定位文件指针就是移动文件指针到我们想要的地方去。

第一个参数是文件指针，第二个参数offset是偏移量(确定偏移量时要考虑开始偏移的起始位置，有三种起始位置，第一个SEEK_SET是从文件起始位置开始偏移，第二个SEEK_CUR是从当前文件指针的位置开始偏移，第三个SEEK_END是从文件末尾开始偏移，正数向左，负数向右，偏移的单位为字节)，第三个参数origin是起始位置。

示例代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	//文件内容：zhangsan
	FILE* pf;
	pf = fopen("E:\\test\\test2.23.txt", "r");
	if (pf == NULL)
	{
		perror("pf");
		return 1;
	}
	int ch = fgetc(pf);      //第一次
	printf("%c\n", ch);     //z

	fseek(pf, 2, SEEK_CUR);
	//文件指针从z处(文件指针目前所指的位置)向右偏移两个字节(a处)

	ch = fgetc(pf);          //第二次
	//文件指针自动指向下一位(n处)
	printf("%c\n", ch);    //n

	ch = fgetc(pf);         //第三次
	//文件指针自动指向下一位(g处)
	printf("%c\n", ch);   //g

	fseek(pf, -2, SEEK_END);
	//从末尾n处向左偏移两个字节(s处)
	ch = fgetc(pf);        //第四次
	//文件指针自动指向下一位(a处)
	printf("%c\n", ch);   //a

	fclose(pf);
	pf = NULL;

	return 0;
}

文件内容：

输出结果：

---

5.2 ftell

ftell的作用就是告诉我们当前文件指针相对于起始位置的偏移量是多少，其参数为文件指针，返回值为偏移量的值。

示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	//文件内容：zhangsan
	FILE* pf;
	pf = fopen("E:\\test\\test2.23.txt", "r");
	if (pf == NULL)
	{
		perror("pf");
		return 1;
	}
	int ch = fgetc(pf);      //第一次
	printf("%c\n", ch);     //z

	fseek(pf, 2, SEEK_CUR);
	//文件指针从z处(文件指针目前所指的位置)向右偏移两个字节(a处)

	int n = ftell(pf);       //目前位置距起始位置的偏移量
	printf("%d\n", n);   //3


	fclose(pf);
	pf = NULL;

	return 0;
}

输出结果：

---

5.3 rewind

rewind的作用让目前文件指针的位置回到文件的起始位置，参数为文件指针。

示例代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	//文件内容：zhangsan
	FILE* pf;
	pf = fopen("E:\\test\\test2.23.txt", "r");
	if (pf == NULL)
	{
		perror("pf");
		return 1;
	}
	int ch = fgetc(pf);      //第一次
	printf("%c\n", ch);     //z

	fseek(pf, 2, SEEK_CUR);
	//文件指针从z处(文件指针目前所指的位置)向右偏移两个字节(a处)

	rewind(pf);                //回到起始位置
	ch = fgetc(pf);         
	printf("%c", ch);       //z

	fclose(pf);
	pf = NULL;

	return 0;
}

输出结果：

---

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

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

数据在内存中以二进制的形式存储，如果不加转换的输出到外存（文件）中，就是二进制文件。

如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

一个数据在内存中是怎么存储的呢？

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

图示：

打开二进制文件： 二进制文件：

---

7. 文件读取结束的判定

7.1 被错误使用的feof

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

fgetc函数在读取结束的时候，会返回EOF 正常读取的时候，返回的是读取到的字符的ASCLL码值

fgets函数在读取结束的时候，会返回NULL 正常读取的时候，返回存放字符串的空间起始地址

fread函数在读取的时候，返回的是实际读取到完整元素的个数 如果发现读取到的完整的元素的个数小于指定的元素个数，就会当作最后一次读取

例如，文件内容拷贝：

//将test2.23的内容拷贝一份，生成test2.24
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	FILE* pfread = fopen("E:\\test\\test2.23.txt", "r");
	if (pfread == NULL)
	{
		return 1;
	}
	FILE* pfwrite = fopen("E:\\test\\test2.24.txt", "w");
	if (pfwrite == NULL)
	{
		fclose(pfread);
		pfread = NULL;
		return 1;
	}
	//文件打开成功
	//读写文件
	int ch = 0;
	while ((ch = fgetc(pfread))!= EOF)
	{
		//写文件
		fputc(ch, pfwrite);
	}
	//关闭文件
	fclose(pfread);
	pfread = NULL;
	fclose(pfwrite);
	pfwrite = NULL;

	return 0;
}

代码运行前：

代码运行后：

成功拷贝：

---

8. 文件缓冲区

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

打个比方，如果当一个老师准备上课时，有很多学生陆陆续续的提问题，不断打断老师讲课，那么课堂效率就会明显下降；若老师说，当一个人攒够10个问题以后才能提问，那么一方面会一定程度上限制同学提问的次数，另一方面也会提高课堂的效率，缓冲区也是这个道理。

例如：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
	FILE* pf = fopen("E:\\test\\test2.23.txt", "w");
	fputs("abcdef", pf);
	//先将代码放在输出缓冲区
	printf("睡眠10秒-已经写数据了，打开t