enum { SIZE = 5 };
int main(void)
{
    double a[SIZE] = { 1.,2.,3.,4.,5. };
    double b[SIZE];

    FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式
    fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组
    fclose(fp);

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

好，走读完上面的这个两个实例，相信你对文件操作应该有了一个更进一步的理解，接下去我们来讲讲有关文件缓冲区的知识

八、文件缓冲区

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

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

==下面是有关文件缓冲区的示意图==

==下面是实例代码==

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

📚拓展：文件外排序【更上一层楼】

说了这么多有文件的操作，但是不实际去使用还是不行的，纸上得来终觉浅，绝知此事要躬行。接下去就让我们来看看如何对一个文件中的数据进行排序

1、前言

• 对于文件中的数据，一般都是很大的，不像我们上面所讲的十二十个数，可能会有成千上百的数据需要我们去排序，此时效率最高的就是【归并排序】了，因为面对海量的数据而言，像效率较高的【快速排序】需要克服三数取中的困难，还有像【堆排序】【希尔排序】这些，都无法支持随机访问，所以很难去对大量的文件进行一个排序，速度会非常之慢。即使是有文件函数【fseek()】这样的函数可以使文件指针偏移，还是很难做到高效。因为磁盘的速度比起内存差了太多太多了，具体的我不太清楚大概有差个几千倍这样，
• 所以我们就想到了【归并排序】，它既是内排序，也是外排序，而且性能也不差，算是速度较快的几个排序之一了。但是要如何进行归并呢？

2、思路解析

• 回忆一下归并排序的原理，就是两个有序区有序，然后两两一归才使得整体可以有序，如果左右都无需，那么继续对其进行左右分割归并
• 但是本次，我要教给你的你是另外一种思路：

将一个大文件平均分割成N份，保证每份的大小可以加载到内存中，然后使用快排将其排成有序再写回一个个小文件，此时就拥有了文件中归并的先决条件

• 具体示意图如下

==这里我设置一个这样的规则，令文件1为【1】，文件2位【2】，它们归并之后即为【12】，然后再让【12】和文件3即【3】归并变成【123】，以此类推，所以最后归出的文件名应该是【12345678910】==

3、代码详解

下面是大文件分割成10个小文件的逻辑，首先来讲解一下这块，代码中很多内容涉及到文件操作，如果有文件操作还不是很懂的小伙伴记得再去温习一下

• 整体的逻辑就在于从文件中读取100个数据，但是分批进行读取，每次首先去读9个数，然后当读到第十个数的时候，先将其加入数组中，然后再对数组中的这10个数进行排序。排完序后就将这个10个数通过文件指针再写到一个小文件中
• 接着当第二次循环上来的时候，就开始读第11~20个数；以此往复，直到读完这个100个数为止，那此时我们的工程目录下就会出现10个小文件，就是对这100个数的分隔排序后的结果

void MergeSortFile(const char* file)
{
	FILE* fout = fopen(file, "r");
	if (!fout)
	{
		perror("fopen fail");
		exit(-1);
	}
	
	int num = 0;
	int n = 10;
	int i = 0;
	int b[10];
	char subfile[20];
	int filei = 1;
	//1.读取大文件，然后将其平均分成N份，加载到内存中后对每份进行排序，然后再写回小文件
	memset(b, 0, sizeof(int) * n);
	while (fscanf(fout, "%d\n", &num) != EOF)
	{
		if (i < n - 1)
		{
			b[i++] = num;	//首先读9个数据到数组中
		}
		else
		{
			b[i] = num;		//再将第十个输入放入数组
			QuickSort(b, 0, n - 1);		//对其进行排序

			sprintf(subfile, "%d", filei++);

			FILE* fin = fopen(subfile, "w");
			if (!fin)
			{
				perror("fopen fail");
				exit(-1);
			}
			//再进本轮排好序的10个数以单个小文件的形式写到工程文件下
			for (int j = 0; j < n; ++j)
			{
				fprintf(fin, "%d\n", b[j]);
			}
			fclose(fin);

			i = 0;		//i重新置0，方便下一次的读取
			memset(b, 0, sizeof(int) * n);
		}
	}

• 我们来看一下排序的结果

• 将大文件分成10个小文件后，接下去就是要对这个10个小文件进行归并，具体规则我上面已经说了
• 下面就是单趟归并的逻辑的，就和我们上面说到的归并排序的代码是很类似的，只不过这里是文件的操作而已。要注意的是对于文件来说是有一个文件指针的，若是你读取了一个之后那么文件指针这个结构体中的数据标记就会发生变化，标记为当然所读内容的下一个了
• 所以我们不能将读取读取小文件中的数据的操作放在while循环中，应该单独将其抽离出来进行判断才才对。若是哪个文件中的数小，那么就将这个数写到新的【mfile】文件中去，然后继续读取当前文件的后一个内容

//文件归并逻辑
void _MergeSortFile(const char* file1, const char* file2, const char* mfile)
{
	FILE* fout1 = fopen(file1, "r");
	if (!fout1)
	{
		perror("fopen fail");
		exit(-1);
	}

	FILE* fout2 = fopen(file2, "r");
	if (!fout2)
	{
		perror("fopen fail");
		exit(-1);
	}

	FILE* fin = fopen(mfile, "w");
	if (!fin)
	{
		perror("fopen fail");
		exit(-1);
	}

	int num1, num2;
	//返回值拿到循环外来接受
	int ret1 = fscanf(fout1, "%d\n", &num1);
	int ret2 = fscanf(fout2, "%d\n", &num2);
	while (ret1 != EOF && ret2 != EOF)
	{
		if (num1 < num2)
		{
			fprintf(fin, "%d\n", num1);
			ret1 = fscanf(fout1, "%d\n", &num1);
		}
		else
		{
			fprintf(fin, "%d\n", num2);
			ret2 = fscanf(fout2, "%d\n", &num2);
		}
	}

	while (ret1 != EOF)
	{
		fprintf(fin, "%d\n", num1);
		ret1 = fscanf(fout1, "%d\n", &num1);
	}
	while (ret2 != EOF)
	{
		fprintf(fin, "%d\n", num2);
		ret2 = fscanf(fout2, "%d\n", &num2);
	}

	fclose(fout1);
	fclose(fout2);
	fclose(fin);
}

最后在打开文件后不要忘了将文件关闭哦，不然就白操作了

• 当然上面是一个单趟的逻辑，我们还要对【file1】【file2】【mfile】进行一个迭代

//利用互相归并到文件，实现整体有序
char file1[100] = "1";
char file2[100] = "2";
char mfile[100] = "12";
for (int i = 2; i <= n; ++i)
{
	_MergeSortFile(file1, file2, mfile);
	
	//迭代
	strcpy(file1, mfile);
	sprintf(file2, "%d", i + 1);
	sprintf(mfile, "%s%d", mfile, i + 1);
	
}

• 大概就是这么一个迭代的过程

==整体代码展示==

//文件归并逻辑
void _MergeSortFile(const char* file1, const char* file2, const char* mfile)
{
	FILE* fout1 = fopen(file1, "r");
	if (!fout1)
	{
		perror("fopen fail");
		exit(-1);
	}

	FILE* fout2 = fopen(file2, "r");
	if (!fout2)
	{
		perror("fopen fail");
		exit(-1);
	}

	FILE* fin = fopen(mfile, "w");
	if (!fin)
	{
		perror("fopen fail");
		exit(-1);
	}

	int num1, num2;
	//返回值拿到循环外来接受
	int ret1 = fscanf(fout1, "%d\n", &num1);
	int ret2 = fscanf(fout2, "%d\n", &num2);
	while (ret1 != EOF && ret2 != EOF)
	{
		if (num1 < num2)
		{
			fprintf(fin, "%d\n", num1);
			ret1 = fscanf(fout1, "%d\n", &num1);
		}
		else
		{
			fprintf(fin, "%d\n", num2);
			ret2 = fscanf(fout2, "%d\n", &num2);
		}
	}

	while (ret1 != EOF)
	{
		fprintf(fin, "%d\n", num1);
		ret1 = fscanf(fout1, "%d\n", &num1);
	}
	while (ret2 != EOF)
	{
		fprintf(fin, "%d\n", num2);
		ret2 = fscanf(fout2, "%d\n", &num2);
	}

	fclose(fout1);
	fclose(fout2);
	fclose(fin);
}

/*文件外排序*/
void MergeSortFile(const char* file)
{
	srand((unsigned int)time(NULL));
	FILE* fout = fopen(file, "r");
	if (!fout)
	{
		perror("fopen fail");
		exit(-1);
	}

	//先写100个随机数进文件
	//for (int i = 0; i < 100; ++i)
	//{
	//	int num = rand() % 100;
	//	fprintf(fout, "%d\n", num);
	//}

	int num = 0;
	int n = 10;
	int i = 0;
	int b[10];
	char subfile[20];
	int filei = 1;

	//1.读取大文件，然后将其平均分成N份，加载到内存中后对每份进行排序，然后再写回小文件
	memset(b, 0, sizeof(int) * n);
	while (fscanf(fout, "%d\n", &num) != EOF)
	{
		if (i < n - 1)
		{
			b[i++] = num;	//首先读9个数据到数组中
		}
		else
		{
			b[i] = num;		//再将第十个输入放入数组
			QuickSort(b, 0, n - 1);		//对其进行排序

			sprintf(subfile, "%d", filei++);

			FILE* fin = fopen(subfile, "w");
			if (!fin)
			{
				perror("fopen fail");
				exit(-1);
			}
			//再进本轮排好序的10个数以单个小文件的形式写到工程文件下
			for (int j = 0; j < n; ++j)
			{
				fprintf(fin, "%d\n", b[j]);
			}
			fclose(fin);

			i = 0;		//i重新置0，方便下一次的读取
			memset(b, 0, sizeof(int) * n);
		}
	}

	//利用互相归并到文件，实现整体有序
	char file1[100] = "1";
	char file2[100] = "2";
	char mfile[100] = "12";
	for (int i = 2; i <= n; ++i)
	{
		_MergeSortFile(file1, file2, mfile);
		
		//迭代
		strcpy(file1, mfile);
		sprintf(file2, "%d", i + 1);
		sprintf(mfile, "%s%d", mfile, i + 1);
		
	}

}

==运行结果展示==

九、总结与提炼

好，我们来总结回顾一下本文所学习的知识

在本文中我们了解了什么是文件，知道了有【数据文件】和【文本文件】两种，接下去主要是对数据文件展开了一系列的操作：

• 首先是说到如何去打开和关闭一个文件，以及打开文件的一些方式。之后讲解了有关文件的顺序读写，里面说到了对文件进行读写的八个常用函数 【fgetc】【fputc】【fgets】【fputs】【fscanf】【fprintf】【fread】【fwrite】，说完顺序读写后我们又讲了随机读写，也给大家讲了三个函数 【fseek】【ftell】【rewind】。其他函数记不住没关系，这是一个函数希望大家可以牢记于心，这样你的文件操作就能更加熟练
• 其次我们又说到了有关【feof】的错误使用，讲解了其该如何去正确使用，这个函数也希望你可以记住，在进行文件判断是否读取完毕的时候可以起到很关键的作用
• 最后，我们又说到了如何对一个文件中的数据去进行排序，充分地将学习的知识运用到了实际的应用中，希望通过这个你对文件的操作可以更上一层楼

最后很感谢您对本文的观看，如有疑问，请于评论区留言或者私信我可以:cherry_blossom: