1️⃣文件概述

1.文件是一组相关数据的有序集合。如，源程序文件、目标文件、可执行文件、库文件(头文件)...。文件通常驻留在外部介质(磁盘、硬盘、U盘...)上的，在使用时才调入内存。	2.程序在执行时，所有的数据都存储在内存中，这些数据只能临时存放而不能永久保存，想要永久保存就需要把数据以文件的形式存储在外存储器中。每一个文件都有一个名字，操作系统以文件为单位对数据进行管理。
3.C语言把外部设备也作为文件对待（外部文件），从而把实际的物理设备抽象化为逻辑文件的概念。每个设备文件都有一个文件名，如打印机作为设备文件时，系统命名为PRN。C语言把磁盘文件和设备文件都作为相同的逻辑文件对待，例如，当我们从键盘输入字符的时候，C语言会把输入设备(即键盘)当做文件来处理，对他们的输入和输出采用相同的方法，这种逻辑上的统一为程序设计提供了很大的方便。

---

1️⃣️1️⃣一个简单的文件操作程序

程序1-1：把短句“Hello World!”保存到磁盘文件“f1.txt”中

#include<stdio.h>
#include<stdlib.h>
int main()
{
    
	FILE* fp;					/* 定义文件指针 */
	fp = fopen("f1.txt", "w");	/* 打开文件 */
	fprintf(fp, "Hello World!");	/* 写文件 */
	fclose(fp);					/* 关闭文件 */
	return 0;
}

程序运行后，在工程默认的文件夹(即源代码存储的文件目录)中可以找到文件f1.txt，文件内容如图1-1所示。

    在打开或者关闭一个文件的时候，需要判断一下是否操作成功，如果打开成功，才能对文件进行接下来的操作。判断语句常用的形式如下：

#include<stdio.h>
#include<stdlib.h>
int main()
{
    
	FILE* fp;		// 定义文件指针
	/* 如果打开文件失败 */
	if((fp = fopen("f1.txt","w")) == NULL);
	{
    
		printf("File open error!\n");
		exit(0);
	}
	if(fclose(fp))	// 如果关闭文件失败
	{
    
		printf("Can not close the file!\n");
		exit(0);
	}
	return 0; 
}

---

1️⃣️2️⃣C文件的分类

C语言从不同的角度对文件进行分类

(1)从用户的角度，文件可分为普通文件和设备文件。

普通文件:保存在磁盘或其他外部文件介质上的一个有序数据集。源文件、目标文件、可执行文件等都是普通文件。
设备文件:指显示器、打印机、键盘等外部设备。C语言把外部设备也看作是一个文件来进行管理，把其输入、输出等同于对磁盘文件的读和写。例如，键盘被默认为标准输入文件，屏幕被默认为标准输出文件。

(2)根据数据的编码形式，可分为文本文件和二进制文件。

文本文件:按一个字节存放一个字符的ASCII码来存放的。例如，整数12345678存储时被视为'1'、'2'、'3'、'4'、'5'、'6'、'7'、'8'，共8个字符，占8个字符。
二进制文件:按数据在内存中的存储形式放到磁盘上的。例如，整数 12345678，在内存中按二进制形式存放，占4个字节。

以文本文件形式输出便于对字符串进行处理，也便于输出字符，但是占用存储空间较多，而且要花费转换时间。以二进制文件形式输出可以节省空间和转换时间，但是不能直接输出字符形式。

---

1️⃣️3️⃣缓冲文件系统

  目前C语言使用的文件系统分为缓冲文件系统(标准 I/O)和非缓冲文件系统(系统I/O)。

• 缓冲区文件的特点：系统自动地在内存区为每个正在使用的文件开辟一个缓冲区，用于临时存储被写入到文件和从文件读取的数据。在向磁盘文件输出数据时，先写入“缓冲区”中，等装满缓冲区后才复制到磁盘文件中。设计原因：内存的读写速度要远远快于硬盘的读写速度。如果我们每写一个字符后就要把它保存在硬盘上，代价太大了。由此可已看出，内存“缓冲区”的大小影响着实际操作外存的次数，内存“缓冲区”越大，则操作外存的次数就越少，执行速度就快，效率就会更高。一般来说，文件“缓冲区”的大小随机器而定，一般为512字节。创建和操纵缓冲区的工作是由操作系统自动完成的。在C语言中将这种缓冲文件系统称为标准输入输出，或称流式输入输出.

• 非缓冲区文件的特点：非缓冲文件系统依赖于操作系统，通过操作系统的功能对文件进行读写，是系统级的输入/输出，C编译器不会自动开辟缓冲区，而要由程序自行设置文件的缓冲区。

• 以键盘输入为例来说明缓冲文件系统和非缓冲文件系统区别：在缓冲文件系统中，输入的字符会先存在输入缓冲区里，同时会回显到屏幕上，在输入回车之后才发送到程序的输入队列中，供程序使用。而在非缓冲文件系统，不需要输入回车来将输入发送给程序，而是键盘的任何输入都直接发送到程序的输入队列中。

---

1️⃣️4️⃣文件指针

    每一个被使用的文件都要在内存中开辟一个区域，用来存放有关信息，包括文件名称、文件状态和当前文件位置等。这些信息被保存在一个结构体变量中，该结构类型被系统定义为FILE,放在<stdio.h>文件中。有些版本的FILE被定义如下：

typedef struct
{
    
	short level;			/* 缓冲区使用量 */
	unsigned flags;			/* 文件状态标准 */
	char fd;				/* 文件描述符 */
	short bsize;			/* 缓冲区大小 */
	unsigned char *buffer;	/* 缓冲区大小 */
	unsigned char *curp;	/* 指向文件缓冲区的工作指针 */
	unsigned char hold;		/* 其他信息 */
	unsigned istemp;
	short token;
}FILE;

ISO C++ 14882: 27.3 Standard中：

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 *fp;

就是定义一个文件指针fp，指向该文件对应的结构变量，即可通过文件指针访问该文件。语句

fp = fopen("f1.txt", "w");

就是给fp赋值，fp便是一个指向f1.txt文件的指针。有了文件指针以后，对文件的操作(读、写和关闭等)都使用文件指针，而不是再用文件名。
    在C语言中，程序开始运行时，系统自动打开3个标准文件：标准输入、标准输出、标准出错输出。通常这3个文件都与终端相联系。系统自定义了3个文件指针stdio、stdout、stderr，分别指向终端文件。其中，显示器被默认为标准输出和标准出错输出的终端，所以前面使用的printf()函数将信息输出到屏幕；而键盘被默认为标准输入终端，前面使用的scanf()从键盘输入数据。

---

---

2️⃣文件打开和关闭

2️⃣️1️⃣文件打开函数fopen()

fopen()函数用来打开一个文件，其调用的一般格式为：

	file_opinter_name = fopen(file_name, operate_way);
	/* 文件指针名 = fopen(文件名, 使用文件方式); */

其中，“文件指针名”必须是被说明为FILE类型的指针变量； “文件名”是被打开文件的文件名，是一个字符串常量或字符数组； “使用文件方式”是指文件的类型和操作要求，常用的文件打开方式如表2-1所示。

	fp1 = fopen("f1.txt", "r");

作用是在当前目录下打开文件f1.txt，只允许进行“读”操作，并使fp1指向该文件。

	fp2 = fopen("E:\\MANIA\\blog\\cs\\z240119_cs_cf\\code_lib\\1-1\\f1.txt", "w");

作用是打开E盘MANIA文件夹中的blog文件夹中的cs文件夹中的z240119_cs_cf文件夹中的
code_lib文件夹中的1-1文件夹中的f1.txt文件，只允许进行“写”操作，并使fp2指向该文件。此语句中，双反斜杠'\\'是转义序列，表示一个反斜杠字符'\'。Windows的路径中用反斜杠分隔文件目录层。

    文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则会返回NULL。若文件打开失败，接下来的读写操作也无法顺利进行，所以一般在fopen()后做错误判断及处理。

	if((fp = fopen("f1.txt","w")) == NULL);
	{
    
		printf("File open error!\n");
		exit(0);
	}

    这种方法在打开文件发生错误时能及时发现并处理。在开始写文件之前，检查诸如文件是否有写保存，磁盘是否已写满等，若打开文件失败，函数会返回一个空指针NULL。事实上打开文件是要向编译系统说明3个信息：①需要访问的外部文件是哪一个。②打开文件后要执行读或写，即选择操作方式。③确定哪一个文件指针指向该文件。
    以上代码段中用到了exit()函数，该函数被定义在stdlib.h中，作用是终止正在执行的程序。但该函数在结束程序之前要检查文件的打开情况，把文件缓冲区中的内容写会文件，然后关闭已打开的所有文件，结束程序运行，返回操作系统，并将“程序状态”返回给操作系统。当值为0时，表示程序正常退出；非0值时，表示程序异常退出（如被任务管理器终止）。

    对打开文件所选择的操作方式，一经说明将不能改变，除非关闭文件后重行打开。常用的文件打开方式参数如表2-1所示。

表 2-1 常用的文件打开方式参数表

文本文件(ASCII)		二进制文件(Binary)
使用方式	含义	使用方式	含义
r	打开只读文件	rb	打开只读文件
w	建立只写新文件	wb	建立只写新文件
a	打开添加写文件	ab	打开添加写文件
r+	打开读/写文件	rb+	打开读/写文件
w+	建立读/写新文件	wb+	建立读/写新文件
a+	打开读/写文件	ab+	打开读/写文件

对于文件的使用方式由以下几点说明：

(1)文件使用方式由r、w、a、t、b、+这6个字符组成，其中，"r"表示"读"；"w"表示"写"；"a"表示"追加"；"t"表示“文本文件”，可以省略不写；"b"表示“二进制文本文件”；"rt"表示“读和写”。

(2)以"r"方式打开文件，指定文件已经存在，否则出错。

(3)用"w"打开的文件只能向该文件写入。若打开的文件不存在，则以指定的文件名建立该文件，若打开的文件已经存在，则将该文件删除，重建一个新文件。

(4)以"a"方式写，如果该文件已经存在，写入的数据将被添加到该文件原有数据的后面，否则以指定的名字新建一个文件(与"w"相同)。

(5)如果文件同时读写，使用"r+"、"w+"、"a+"打开文件。

在打开文件操作时，需注意：️
①为了读而打开一个不存在的文件，是一个错误；
②同样滴，在没有空余的硬盘空间的情况下，为写而打开一个文件，也是一个错误；
③用不正确的文件打开模式来打开一个文件，是一个逻辑错误。
④因此，在打开文件时，一定要明确对该文件所做的操作是什么，从而使用正确的打开模式。如果一个文件的内容不允许被修改，就用只读模式（不更新）来打开这个文件，这有助于预防对文件内容无意修改，这也符合“最小权限原则”。

---

2️⃣️2️⃣文件的关闭函数fclose()

    fclose()函数用来关闭一个文件，其调用的一般形式为：

	fclose(file_pointer);		// file_pointer：文件指针

    fclose()函数关闭文件指针所指的文件，也就是使用文件指针变量与文件“脱钩”。fclose()函数关闭文件操作成功后，函数返回0,失败返回非零值。程序2-1中的如下代码段展示了正确关闭文件的方法。

	if(fclose(fp))	// 如果关闭文件失败
	{
    
		printf("Can not close the file!\n");
		exit(0);
	}

    调用fclose()函数关闭文件时，系统把缓冲区中的数据写入磁盘区，确保写文件的正常完成；释放文件缓冲区单元和FILE结构体，时文件指针与具体文件脱钩。如果正常关闭文件，返回值为0；无法正常关闭文件，则返回EOF:[-1]。

    为了养成良好的编程习惯，需要记住一旦明确程序不再访问一个文件后，需要立即显式地关闭该文件。关闭一个文件可以释放掉其所占用的资源。

---

2️⃣️3️⃣输入/输出重定向函数freopen()

    在程序运行时，系统会自动打开3个标准文件，即标准输入文件(stdin)，通常对应终端的键盘；标准输出文件(stdout)和标准错误输出文件(stderr)，这两个文件都对应终端屏幕。使用标准输入/输出设备文件存在的问题是：

    (1)从键盘输入数据时，用户输入的数据只能用一次，下次在想用这些数据时就得重新输入，而且若输入有误修起来不是很方便
    (2)输出到屏幕上的信息只能看不能编辑，无法对此输出做更多处理，例如将输出作为另一个程序的输入进行进一步的处理等。

    为了解决上述问题，C标准函数库提供了输入/输出重定向函数freopen()。freopen()函数主要用于改变stdin、stdout、stderr所关联的文件（使标准设备转向外部存储设备）。

    输入重定向把可执行程序的标准输入重定向到指定的文件中。也就是说，输入可以不来自键盘，而来自一个指定的文件。语句

	freopen("in.txt", "r", stdin);

就是把标准输入流stdin重定向到in.txt文件中，这样在使用sccanf()输入时，便不会从键盘读取数据，而是从in.txt文件中获取输入

    输出重定向是把可执行程序的标准输出或标准错误输出重定向到指定文件中。语句

	freopen("out.txt", "w", stdout);

就是把stdout重定向到out.txt文件中，这样输出结果不会显示到标准输出设备上，而是保存到out.txt文件中。

    使用freopen()函数可以解决测试数据的输入问题，避免重复输入。下面的程序2将会把标准输入stdin重定向到in.txt文件中，这样在用scanf()输入时便不会从标准输入流读取数据，而是从in.txt文件中获取输入。只要把输入数据事先粘贴到in.txt，调试时就方便多了。类似地，也可以把标准输出stdout重定向到out.txt文件中。

/* 程序2：计算a+b。从in.txt文件中读取数据，结果保存在out.txt文件中 */

#include<stdio.h>
int main()
{
    
	int a, b;
	freopen("in.txt", "r", stdin);	// 输入重定向，输入数据将从 in.txt 文件中读取
	freopen("out.txt", "w", stdout);// 输出重定向，输出数据保存在 out.txt 文件中
	
	while(scanf("%d%d", &a, &b) != EOF)
		printf("%d\n", a + b);
	
	fclose(stdin);					// 关闭文件
	fclose(stdout);					// 关闭文件
	return 0; 
}

在程序2中，需要注意的是：
(1)在freopen("in.txt","r",stdin)中，in.txt文件应放在所建立的工程文件夹下。
(2)in.txt文件也可以放在其他文件夹下，只需要所在路径正确即可。如：

	freopen("E:\MANIA\blog\cs\z240119_cs_cf\code_lib\2\in.txt","r",stdin);

    输出重定向比输入重定向更常用，在很多情况下使用这种功能。例如，如果某个命令的输出很多，在屏幕上不能完全显示，那么将输出重定向到一个文件中，然后再用文本编辑器打开这个文件，就可以查看输出信息；如果想保存一个程序的输出结果，也可以使用这种方法。

---

---

3️⃣文件的读/写操作

    对文本文件的读写，涉及ASCII码和二进制码的转换问题，而二进制文本的读写则不存在这种转换。文件的读写操作是通过调用文件读写库函数来实现的。

3️⃣️1️⃣字符读/写函数fgetc()、fputc()

    关于文件的读写操作，这里先介绍用于读（写）单个字符的库函数，这些函数可以处理文本文件和二进制文件。

（1）字符写函数fputc():

fputc()函数的功能是把一个字符写到磁盘文件上，同时移动读写位置指针到下一个写入位置。一般调用形式为：

	fputc(字符型变量, 文件指针);

如果写文件成功，返回该字符型变量，写文件失败，则返回EOF:-1。

（2）字符读函数fgetc():

fgetc()函数的功能是从磁盘文件读取一个字符。一般调用形式如下：

	fgetc(文件指针);

返回值为从文件指针所指示的磁盘文件读出的一个字符，同时将读写位置指针向后移动1个字节(即指向下一个字符)。该函数无错误返回值。

加油站：字符常量EOF，其值在头文件stdio.h中被定义为-1。在对文本文件执行读入操作时，如果遇到文件尾，则读操作函数返回一个文件结束标志EOF。

试试看：文件中字符读/写操作
将键盘上输入的一个字符串（以"@"作为结束字符），以ASCII码形式存储到一个磁盘文件f2.txt中，再顺序显示出这个磁盘文本文件。
解题思路：
这个程序要对f2.txt分别进行写和读操作。从键盘输入字符写入f2.txt时，文件按写方式打开；将f2.txt的内容显示到屏幕时，文件按读写方式打开。在这里，读和写是两种不同的操作，f2.txt分别被打开和关闭两次。

/* 程序3:字符的读/写操作 */

#include<stdio.h>
#include<stdlib.h>
int main()
{
    
	FILE* fp;
	char ch;
	
	if( (fp = fopen("f2.txt", "w")) == NULL )	// 打开文件失败
	{
    
		printf("Can not open this file\n");
		exit(0);
	}
	for( ; (ch=getchar()) != '@'; )
		fputc(ch, fp);					// 输入字符并存储到文件中
	fclose(fp);							// 关闭文件
	
	if( (fp = fopen("f2.txt", "r")) == NULL )
	{
    
		printf("can not open source file\n");
		exit(0);
	}
	for( ; (ch = fgetc(fp)) != EOF; )
		putchar(ch);					// 顺序输出文件的内容

	fclose(fp);				// 关闭打开的文件
	return 0; 
}

C语言允许同时打开多个文件，不同的文件对应的文件指针。但是C语言不允许同一个文件在关闭之前再次打开。

3️⃣️2️⃣字符串读/写函数fgets()、fputs()

    对一个字符串的读/写，可以整体处理，即用fputs()函数向文件写入字符串，用fgets()函数从文件中读出一个字符串。

（1）字符串写函数fputs():

fputs()函数用来指定的文本文件写入一个字符串，一般调用形式为：

	fputs(字符数组, 文件指针);

其中字符数组表示要写入的字符串，可以是一个字符串常量、或字符串指针变量名。需要注意的是结束字符'\0'不写入文件。
如果操作成功，函数返回一个非负数；否则，函数返回EOF。

（2）字符串读函数fgets():

fgets()函数从文本文件中读取字符串，一般调用形式为：

	fgets(字符数组, 字符数组, 文件指针);

如果操作成功，函数返回读取的字符串；如果失败，则返回空指针，这是字符串的内容不确定。
其中：
·字符数组：可以是字符组名或字符指针；字符个数：指定读入的字符个数；文件指针：指向操作文件。
·从指定文件读入一个字符串，存入字符数组，并在尾端自动加一个'\0'；同时，将读写位置指针向后移动strlength（字符串长度）个字符。
·如果在读入规定长度之前遇到文件结束标志EOF或转换符，读入即结束。若有换行符，则将换行符保留（换行符保留在'0'字符之前）；若有EOF，则不保留。

试试看：文件中字符串读/写操作
将键盘上输入的一个长度不超过80的字符串，以ASCII码形式存储到一个磁盘文件f3.txt中，然后再输出到屏幕上。

/* 程序4:字符串的读/写操作 */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    
	FILE* fp;
	char string[81];			// 字符数组用于暂存输入/输出的字符串 
	
	if( (fp = fopen("f3.txt", "w")) == NULL )	// 如果打开文件失败
	{
    
		printf("can not open this file\n");
		exit(0);
	}
	printf("Input a string:");
	gets(string);				// 从键盘上输入字符串
	fputs(string, fp);			// 存储到指定文件
	fclose(fp);
	
	/* 重新打开文件，读出其中的字符串，并输出到屏幕上 */
	if( (fp = fopen("f3.txt", "r")) == NULL )	// 如果打开文件失败
	{
    
		printf("can not open this file\n");
		exit(0);
	}
	
	fgets(string, strlen(string)+1, fp);	// 从文件中读一个字符串
	printf("Output the string:");
	puts(string);				// 将字符串输出到屏幕上
	fclose(fp);
	return 0;
}

---

3️⃣️3️⃣格式化文件读/写函数fscanf()、fprintf()

    fscanf()、fprintf()与scanf()、printf()作用相似，都是格式化读写函数。只是前者对磁盘文件的读写，后者是对终端的读写。

一般调用形式如下：

	fscanf(文件指针, 格式字符串, 输入表);
	fprintf(文件指针, 格式字符串, 输出表);

例如，下面这段代码，表示从文件a.txt分别读入整型数据到变量n、浮点类型到变量x：

	FILE* fp; int n; float x;
	fp = fopen("a.txt", "r");
	fscanf(fp, "%d%f", &n, &x);

下面这段代码表示把表量n和x的数值写入文件b.txt：

	fp = fopen("b.txt", "w");
	fprintf(fp ,"%d%f", n, x);

/* 程序5:dat1.txt存放的是一系列整型数据，从dat1.txt中读出20个数存入数组中，并写入到dat2.txt中，同时将写入的数据输入到屏幕上 */

#include<stdio.h>
#include<stdlib.h>
int main(void)
{
    
	FILE* fp, *fp1;
	int i, count = 0;
	int array[20];
	
	fp = fopen("dat1.txt", "r");
	if(fp == NULL)
	{
    
		printf("Can not read data from file dat1.txt!\n");
		exit(1);
	}
	
	fp1 = fopen("dat2.txt", "w");
	if(fp == NULL)
	{
    
		printf("Can not write data to file dat2.txt!\n");
		exit(1);
	}
	
	for(i = 0; i < 3; i++)			// 从文件 dat1.txt 读取 3 个整数，存入数组 array
		fscanf(fp, "%d", array+i); 
	for(i = 0; i < 3; i++)			// 将数组 array 中前 3 个元素写入文件 dat2.txt 
		fprintf(fp1, "%d\n", *(array+i));
	
	for(i = 0; i < 3; i++)
		printf("%d\n", *(array+i));
	fclose(fp1);
	fclose(fp);
	return 0;
}

---

3️⃣️3️⃣数据块读/写函数fread()、fwrite()

    在实际应用中，常常要求把成组的数据写入到文件中或从文件读出到内存中来。为此，ANSII标准设置了fread()和fwrite()函数，可以实现对数据的整体读写。它们通常用于读写二进制文件，被读写的数据可以是一个结构体或数组，也可以是一个简单数据，总之，要求文件中每一组数据的存储长度相同。一般调用形式如下：

	fread(数据区首地址, 每次读取的字节数, 读取次数, 文件指针);
	fwrite(数据区首地址, 每次写入的字节数, 写入次数, 文件指针);

    函数调用成功，返回值为数据个数；如果实际执行读/写的次数小于指定次数，那么返回实际的次数；如果函数调用失败，返回值为0。

    其中，fread()从文件指针指向的文件中读取一批数据存放到数据首地址开始的区域中。
    fwrite()将从数据存储区首地址开始的若干个数据写入文件指针指向的文件中，数据存储区首地址可以是数组名、结构变量名、指针
    若有如下定义：

struct student
{
    
	char name[10];
	int score;
}stu, stuArr[10], STU, STUArr[10];

    若将一个结构体变量写入文件，语句如下：

	fwrite(&stu, sizeof(stu), 1, fp);

    若将结构体数组stuArr写入文件，语句如下：

	fwrite(stuArr, sizeof(stuArr), 1, fp);

    若将结构数组stuArr的前10个元素写入文件，语句如下：

	fwrite(stuArr, sizeof(stuArr[0]), 10, fp);

/* 程序5’:数据块的写/读案例 */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct student
{
    
	char name[10];
	int score;
}stu, stuArr[10], STU, STUArr[10];

int main(void)
{
    
	int i;
	FILE* fp = fopen("datablock.txt", "w");
	if(fp == NULL){
    
		printf("Can not open data from file dat1.txt!\n");
		exit(1);
	}
	
	strcpy(stu.name, "夏欣"), stu.score = 100;
	strcpy(stuArr[0].name, "陈菲"), stuArr[0].score = 99;
	strcpy(stuArr[1].name, "陈芯"), stuArr[1].score = 98;
	strcpy(stuArr[2].name, "郭姊怡"), stuArr[2].score = 97;
	strcpy(stuArr[3].name, "力绣玲"), stuArr[3].score = 96;
	strcpy(stuArr[4].name, "冉晓玲"), stuArr[4].score = 95;
	strcpy(stuArr[5].name, "杨美铃"), stuArr[5].score = 94;
	strcpy(stuArr[6].name, "王小琳"), stuArr[6].score = 93;
	strcpy(stuArr[7].name, "周静"), stuArr[7].score = 92;
	strcpy(stuArr[8].name, "谭雅林"), stuArr[8].score = 100;
	strcpy(stuArr[9].name, "夏菲"), stuArr[9].score = 100;
	
	/* 若将一个结构体变量写入文件，语句如下： */
	fwrite(&stu, sizeof(stu), 1, fp);
	
	/* 若将结构体数组 stuArr 写入文件，语句如下： */
	fwrite(stuArr, sizeof(stuArr), 1, fp);
	
	/* 若将结构数组 stuArr 的前 10 个元素写入文件，语句如下： */
	fwrite(stuArr, sizeof(stuArr[0]), 10, fp);
	
	fclose(fp);
// <--------------------------------|-------|--------------------------------------->
	fp = fopen("datablock.txt", "r");
	if(fp == NULL){
    
		printf("Can not read data from file dat1.txt!\n");
		exit(1);
	}
	
	/* 若将文件中的数据写入一个结构体变量，语句如下： */
	fread(&STU, sizeof(STU), 1, fp);
	printf("%-11s%9s\n", "姓名", "成绩");
	printf("%-11s%9d\n", STU.name, STU.score);
	
	/* 若将文件数据写入结构体数组 stuArr ，语句如下： */
	fread(STUArr, sizeof(STUArr), 1, fp);
	for(i = 0; i < 10; i++)
		printf("%-11s%9d\n", STUArr[i].name, STUArr[i].score);
	
	/* 若将文件数据写入结构数组 stuArr 的前 10 个元素，语句如下： */
	fread(STUArr, sizeof(STUArr[0]), 10, fp);
	for(i = 0; i < 10; i++)
		printf("%-11s%9d\n", STUArr[i].name, STUArr[i].score);
	
	fclose(fp);
	return 0;
}

---

---

4️⃣文件的定位与检测

4️⃣️1️⃣文件定位函数

    前面所讲的函数都是顺序读/写一个文件，即打开一个文件后都有一个读写指针来标识读写文件位置，根据打开模式指向文件的起始处或结尾处。在顺序读/写过程中，读写位置指针从文件的首部开始逐个对数据进行读写，每完成一个数据的读写，读写指针就指向下一个数据。向文件读写字符的位置是由读写指针指向的位置决定。它与文件指针是不同的，文件指针一旦被指向某个文件，其值是不会改变的，直到该文件被关闭为止。

（1）位置指针指定函数fseek():

fseek()函数可以将位置指针移动到指定的位置，一般调用形式为：

	sfeek(文件指针, 位移量, 起始点);

其中：
·位移量：以起点为基准，向文件尾或文件头移动的字节数，如果是正数，表示向文件尾移动，如果是负数，表示向文件头移动。
·起始点：起始位置。文件头、当前位置和文件尾部分分别对应0、1、2，或常量SEEK_SET、SEEK_CUR、SEEK_END。例如：

	fseek(fp, 20L, 0);			// 将文件位置指针移动到离文件首 20 字节处
	fseek(fp, -20L, SEEK_END);	// 将文件位置指针从文件尾向文件首移动 20 字节处

（2）位置指针复位函数rewind():

    rewind()函数使文件的位置指针返回到文件的首地址，即打开文件时文件指针所指向的位置。一般调用形式为：

	rewind(文件指针);

    此函数没有返回值。

（3）返回文件当前位置函数ftell():

    由于文件的位置指针可以任意移动，也经常移动，往往容易迷失当前位置，ftell()函数就可以解决这个问题。一般调用形式为：

	ftell(文件指针);

    操作成功时，返回文件位置指针的当前位置（用相当于文件头的位移量表示）。操作失败时，返回-1L。

|程序6:利用位置定位函数随机读/写文件|

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(void)
{
    
	FILE* fp;
	char t[20];
	char s[] = "How are you!";
	
	if( (fp = fopen("d1.txt", "wb+")) == 0){
    
		printf("File open error!\n");
		exit(1);
	}
	fwrite(s, strlen(s), 1, fp);	// 向 fp所指向的文件 d1.txt 中块写入字符串
	fseek(fp, 2L, 0);				// 文件指针从文件头向文件尾移动 2 个字节
	fread(t, 7, 1, fp);				// 从文件指针当前位置读取 7 个字节存入数组 t 中
	t[7] = '\0';					// 在数组中数据尾加字符串结束符
	printf("%s\n", t);
	fclose(fp);
	return 0; 
}

|程序6运行结果|

w are y

---

4️⃣️2️⃣文件定位检测

（1）检测文件结束函数feof():

    函数feof()用于判断fp指针是否已经到达文件末尾，用于判断文件是否结束。如果到文件结束位置，返回值为1，如果文件未结束，返回值为0。一般调用形式为：

	feof(文件指针);

    它只适用于文本文件而不适用于二进制文件。

加油站：字符常量EOF:End of File。

（2）检测文件操作错误函数ferror():

    函数ferror()用于检测文件在用各种输入输出函数进行读写是否出错，若返回值为0，表示未出错，否则表示有错误。一般调用形式为：

	ferror(文件指针);

    对同一文件，每次调用输入/输出函数均产生一个新的ferror()函数值。因此在调用了输入/输出函数后，应立即检测，否则出错信息会丢失。
    在执行fopen()函数时，系统会将ferror()的值自动置为0。

（3）清除错误标志函数clearerr():

    函数clearerr()的功能是用来清除出错标志，把它们都置为0。一般调用形式为：

	clearerr(文件指针);

    当调用读写函数出错时，ferror()函数返回值为非0，这时可以通过调用clearerr()清除出错标志，ferror()的返回值将恢复为0。

|程序6z:利用feof()、ferror()、clearerr()函数进行文件检测|

#include<stdio.h>
#include<stdlib.h>

int main(void)
{
    
	FILE* fp;
	char str[30];
	if( (fp = fopen("6x.txt", "r")) == NULL)
	{
    
		printf("File open error!\n");
		printf("ferror = %d\n", ferror(fp));
		printf("feof = %d\n", feof(fp));
		exit(1);
	}
	printf("ferror = %d\n", ferror(fp));
	printf("feof = %d\n", feof(fp));
	
	fgets(str, 30, fp);
	printf("str: %s\n", str);
	printf("ferror = %d\n", ferror(fp));
	printf("feof = %d\n", feof(fp));
	close(fp);
	return 0;
}

---

---

5️⃣学生信息管理系统️

    下面将详细介绍一个具体项目的开发过程，以帮助读者进一步理解文件的基本操作以及程序的模块设计思想。

解决问题：设计并实现一个学生信息系统管理系统
    设计并实现一个学生信息管理系统，能够对一个文件中所有存储的学生信息进行各种常见操作，如排序、查找、计算、显示等功能，其中学生信息包括学生、姓名、性别、5门课的成绩、总成绩以及平均成绩。该功能实现的具体功能如下：

（1）添加学生信息
（2）修改学生信息（按学号）
（3）排序（分别按总分升序、降序以及按姓名升序）
（4）查找学生（按学号）
（5）删除学生
（6）查看所有学生信息

解题思路
    在明确了系统要实现的功能之后，首先要考虑的就是数据结构，也就是系统重所涉及的数据应该如何来表示；一旦确定了数据结构，就可以按照模块化程序设计的思想对系统进行分析和设计，以次确定每个功能模块对应的函数；接着分析整个系统的流程，按流程调用各功能函数；最后是每个函数的具体实现。下面按照此思路对系统进行分析和实现。

1.数据结构设计
    本系统涉及的学生的基本信息包含很多数据项，需要定义如下结构类型 STU，而所有学生的信息保存在结构数组中。

typedef struct student
{
    
	char ID[10];		//学号
	char name[20];		// 姓名
	char sex;			// 性别
	float score[5];		// 五门学科成绩
	float total;		// 总成绩
	float avg;			// 平均成绩 
} STU;

2.功能模块设计
    按照模块化程序设计思想，对任务进行分解，先对最高层的问题进行定义，分解为多个子任务，子任务可以继续划分，直到每个子任务都可以由一个具体的函数实现。这样，就可以得到一系列以功能块为单位的函数定义。学生信息管理系统的功能模块结构图如图2所示，其中第三层列出了排序子任务的功能划分。

3.各模块的设计与实现
（1）主控模块
    在主函数中首先调用load()函数，把文件中的学生信息全部读取到结构数组中，然后调用display()函数显示主菜单，接着输入选项，然后根据选项调用不同函数执行相应功能。系统总体流程图如图3所示。

主控模块中调用了如下函数：

void display(void);						/* 显示主菜单 */
void load(STU stu[], int *nPtr) ;		/* 把学生信息加载到内存 */
void save(STU stu[], int n)	;			/* 将输入保存到磁盘 */
void sort(STU stu[], int n)	;			/* 排序 */
void find(STU stu[], int n)	;			/* 查找 */
void del(STU stu[], int *nPtr);			/* 删除 */
void add(STU stu[], int *nPtr);			/* 添加一条信息 */
void edit(STU stu[], int n)	;			/* 修改一条记录 */
void output(STU stu[], int n);			/* 输出所有信息 */

main()函数内容如下：

int main(void) 		// int argc, char *argv[]
{
    
	STU stu[N];
	int n;
	int select;
	printf("%d------------\n", n);
	load(stu, &n);
	printf("%d------------\n", n);
	while(1)
	{
    
		display();
		scanf("%d", &select);
		switch(select)
		{
    
			case 1: add(stu, &n);	break;			// 添加
			case 2: edit(stu, n);	break;			// 修改
			case 3: sort(stu, n);	break;			// 排序
			case 4: find(stu, n);	break;			// 查找 
			case 5: del(stu, &n);	break;			// 删除
			case 6: output(stu, n);	break;			// 输出
			case 7: return 0;						// 退出 
			default: printf("菜单选择错误!!!\n"); break;
		}
	}
	return 0;
}

（2）显示主菜单项函数display()：

void display(void)
{
    
	system("cls");
	printf("欢迎使用本学生成绩管理系统\n");
	printf("说明:在本系统中欲执行某功能请输入相应数字\n");
	printf("1 添加\n");
	printf("2 修改\n");
	printf("3 修改\n");
	printf("4 查找\n");
	printf("5 删除\n");
	printf("6 输出\n");
	printf("7 退出\n");
}

（3）将学生从文件加载到数组stu的函数load()：

void load(STU stu[], int *nPtr)		// 将学生从文件加载到数组 stu 的函数 load() 
{
    
	FILE *fp;
	int i;
	if((fp = fopen("student.dat", "r")) == NULL)
	{
    
		printf("No student\n");
		*nPtr = 0;
		return ;
	}
	/* 把文件中的信息全都读取到 stu 中 */
	for(i = 0; fread(&stu[i], sizeof(STU), 1, fp) != 0; i++) ;
	*nPtr = i;			/* *nPtr 记录文件中当前学生数量 */
	fclose(fp);			/* 关闭文件 */
}

（4）将数据保存到磁盘的函数save()：

void save(STU stu[], int n)			// 将数据保存到磁盘的函数 save()
{
    
	FILE *fp;
	if((fp = fopen("student.dat", "w")) == NULL)
	{
    
		printf("文件打开失败\n");
		exit(0);
	}
	fwrite(stu, n * sizeof(stu[0]), 1, fp);
	fclose(fp);
}

（5）输出所有学生信息的函数output()：
首先输出表头，然后在循环中调用PrintRecord()显示每一个记录的内容。

void output(STU stu[], int n)		// 输出所有学生信息的函数 output()
{
    
 	int i;
 	/*  打印表头 */
 	
 	printf("%8s%8s%4s%8s%8s%8s%8s%8s%8s%8s\n", "ID", "NAME", "SEX", "SCORE1", "SCORE2", "SCORE3", "SCORE4", "SCORE5",\
	 		"total", "avg");

	/*  打印所有记录 */
	for(i = 0; i < n; i++)
		PrintRecord(&stu[i]);
	system("pause");
}
void PrintRecord(STU *sPtr)			// 输出指针 sPtr所指记录的内容 
{
    
	int i;
	printf("%8s%8s%4c", sPtr->ID, sPtr->name, sPtr->sex);
	for(i = 0; i < 5; i++)
		printf("%8.2f", sPtr->score[i]);
		
	printf("%8.2f%8.2f", sPtr->total, sPtr->avg);
	printf("\n");
 } 

（6）添加记录的函数add()：
    本模块调用函数InputRecord()将新记录添加在数组指定位置上。可以连续添加任意多个新记录，在添加一个新记录之后，查询是否继续添加记录。最后调用函数save()把新添加的学生信息保存到文件中。

void add(STU stu[], int *nPtr)		// 添加记录的函数  
{
    
	int i = 0;
	char sel = 'y';
	while(sel == 'y')
	{
    
		InputRecord(stu, (*nPtr)++);	// 添加第 n+1 个学生 
		printf("是否继续添加(yes--y,no---others)\n");
		scanf(" %c", &sel);
	}
	save(stu, *nPtr);
}

函数InputRecord()读入一个学生信息，存入数组元素stu[i]。

void InputRecord(STU stu[], int i)		// 读入一个学生的信息,存入数组元素 stu[i] 
{
    
	int j;
	
	/* 输入学号，并验证合法性 */ 
	printf("请输入第%d个学生信息\n", i+1);
	
	printf("请输入学生学生号(学号小于9位数字组成)\n");
	scanf("%s", &stu[i].ID);
	
	/* 输入姓名 */
	printf("请输入姓名\n");
	scanf("%s", stu[i].name);
	
	printf("请输入学生性别(f 或 m [f: 代表女性 m: 代表男性])\n");
	scanf(" %c", &stu[i].sex);
	
	/* 输入5门成绩并累加 */
	printf("请输入五门课成绩(0~100)\n");
	stu[i].total = 0;
	
	for(j = 0; j < 5; j++){
    
		scanf("%f", &stu[i].score[j]); // %lf
		stu[i].total += stu[i].score[j];
	}
	
	/* 计算总成绩 */
	stu[i].avg = stu[i].total / 5;
}

（7）修改学生信息的函数edit()：
    该函数首先按用户输入的学号，调用函数FindByNum()找到要修改的记录，然后调用（5）中定义过的函数PrintRecord()显示该记录的内容，再逐项询问是否需要修改，最后调用（4）中定义的函数save()更新文件。

void edit(STU stu[], int n)				// 修改学生信息函数 edit()
{
    
//	修改指定记录
	int i, index;
	char sel;
	char str[20];
	printf("请输入学号: \n");
	scanf("%s", str);
	
	index = FindByNum(stu, n, str);
	
	if(index < 0)
	{
    
		printf("该学生信息不存在\n");
		return ; 
	} 
	 
	printf("修改前的记录如下: \n");
	PrintRecord(&stu[index]);
	
	/*  修改姓名 */
	printf("是否修改姓名? 请输入 y or no:\n");
	scanf(" %c", &sel);
	
	if(sel == 'y')
	{
    
		printf("请输入姓名:\n");
		scanf("%s", stu[index].name);
	}
	/* 修改性别 */
	printf("是否修改性别? 输入 y or n:\n");
	scanf(" %c", &sel);
	if(sel == 'y')
	{
    
	printf("请输入 f or n:\n");
	scanf(" %c", &stu[index].name);
	}
	/* 是否修改成绩 */
	printf("是否修改成绩? input y or n:\n");
	scanf(" %c", &sel);
	if(sel == 'y')
	{
    
		stu[index].total = 0;
		
		printf("请输入5学科成绩:\n"); 
		for(i = 0; i < 5; i++){
    
			scanf("%f", &stu[index].score[i]); // %lf
			stu[index].total += stu[index].score[i];
		}
		/* 计算总成绩 */
		
		stu[index].avg = stu[index].total / 5;
	}
	save(stu, n);
 } 

函数FindByNum()按学号查找需要修改的记录，返回下标。

int FindByNum(STU stu[], int n, char *str)	/* 函数 FindByNum()按学号查找需要修改的记录，返回下标 */
{
    
	int i;
	for(i = 0; i < n; i++)		// 若找到，返回对应下标 
		if(strcmp(stu[i].ID, str) == 0)
			return i;
	return -1;
} 

（8）排序函数sort()：
    本模块定义3个比较函数，分别按照总分升序、按总分降序、按姓名排序3个不同的排序规则，来判断两个记录是否逆序。函数指针cmp可以根据用户的选择指向不同的比较函数，而在比较交换排序的过程中，通过函数指针cmp调用对应的比较函数。

void sort(STU stu[], int n)		// 8. 排序函数sort()
{
    
	int select, i, j;
	int (*cmp)(STU a, STU b);
	
	int ScoreAsc(STU a, STU b);
	int ScoreDes(STU a, STU b);
	int NameAsc(STU a, STU b);
	
	printf("1 按总分升序排列\n");
	printf("2 安总分降序排列\n");
	printf("3 按姓名排列\n");
	scanf("%d", &select);
	switch(select)
	{
    
		case 1: cmp = ScoreAsc; break;
		case 2: cmp = ScoreDes; break;
		case 3: cmp = NameAsc; break;
		default:
			return ;
	}
	/* 按照指定规则，进行比较交换排序 */
	
	for(i = 0; i < n-1; i++)
		for(j = i+1; j < n; j++)
			if((*cmp)(stu[i], stu[j]) > 0)
			{
    
				STU temp;
				temp = stu[i];
				stu[i] = stu[j];
				stu[j] = temp;
			}
	output(stu, n);
} 

int ScoreAsc(STU a, STU b)				// 按成绩升序规则，若 a, b 逆序，返回 1 
{
    
	return a.total > b.total? 1 : -1;
}

int ScoreDes(STU a, STU b)				// 按成绩降序规则，若 a, b 逆序，返回 1 
{
    
	return a.total < b.total? 1 : -1;
 } 

int NameAsc(STU a, STU b)				// 按姓名升序规则，若 a, b逆序，返回一个 正整数 
{
    
	return strcmp(a.name, b.name);
}

（9）按学号查找记录的函数find()：
    本函数调用（7）中定义的FindByNum()函数，若找到，调用函数PrintRecord()输出当前记录，否则，输出“该学生信息不存在”。

void find(STU stu[], int n)				// 9 按学号查找记录的函数find() 
{
    
	int index;
	char str[20];
	
	printf("请输入学号:\n");
	scanf("%s", &str);
	index = FindByNum(stu, n, str);
	
	if(index >= 0)
		PrintRecord(&stu[index]);
	else
		printf("该学生信息不存在\n");
		
	system("pause");
}

（10）删除指定记录的函数del()：
    本函数调用在（5）中定义的FindByNum()函数，得到对应下标，然后删除该记录并调用（4）中定义的函数save()更新文件。

void del(STU stu[], int *nPtr)			// 10 删除指定记录的函数 
{
    
	int i, index;
	char str[20];
	
	printf("请输入学号:\n");
	scanf("%s", str);
	index = FindByNum(stu, *nPtr, str);
	
	if(index < 0)
	{
    
		printf("\n该学生信息不存在\n");
		return ;
	}
	for(i = index; i < *nPtr-1; i++)
		stu[i] = stu[i+1];
	
	(*nPtr)--;
	printf("\n删除成功\n");
	save(stu, *nPtr);		// 保存文件 
}

    至此，系统所有模块均已实现，但要确保任何一个函数调用之前，编译器已获得该函数的函数原型。建议将所有函数的函数原型声明放在程序中的所有函数定义之前，并且在预处理指令、类型定义之后。

|程序7:学生信息管理系统|

#include <stdio.h>
#include <stdlib.h>
#include<ctype.h>
#include<string.h>
#define N 1000

typedef struct student
{
    
	char ID[10];		//学号
	char name[20];		// 姓名
	char sex;			// 性别
	float score[5];		// 五门学科成绩
	float total;		// 总成绩
	float avg;			// 平均成绩 
} STU;
void display(void);						/* 显示主菜单 */
void load(STU stu[], int *nPtr) ;		/* 把学生信息加载到内存 */
void save(STU stu[], int n)	;			/* 将输入保存到磁盘 */
void sort(STU stu[], int n)	;			/* 排序 */
void find(STU stu[], int n)	;			/* 查找 */
void del(STU stu[], int *nPtr);			/* 删除 */
void add(STU stu[], int *nPtr);			/* 添加一条信息 */
void edit(STU stu[], int n)	;			/* 修改一条记录 */
void output(STU stu[], int n);			/* 输出所有信息 */

void PrintRecord(STU *sPtr)	;		// 输出指针 sPtr所指记录的内容 
void InputRecord(STU stu[], int i);		// 函数InputRecord() 读入一个学生的信息,存入数组元素 stu[i] 
int FindByNum(STU stu[], int n, char *str);	/* 函数 FindByNum()按学号查找需要修改的记录，返回下标 */

int ScoreAsc(STU a, STU b);				// 按成绩升序规则，若 a, b 逆序，返回 1 
int SocreDes(STU a, STU b);				// 按成绩降序规则，若 a, b 逆序，返回 1 
int NameAsc(STU a, STU b);				// 按姓名升序规则，若 a, b逆序，返回一个 正整数 


/* 显示主菜单 */
void display(void)
{
    
//	system("cls");
	printf("欢迎使用本学生成绩管理系统\n");
	printf("说明:在本系统中欲执行某功能请输入相应数字\n");
	printf("1 添加\n");
	printf("2 修改\n");
	printf("3 修改\n");
	printf("4 查找\n");
	printf("5 删除\n");
	printf("6 输出\n");
	printf("7 退出\n");
}

void load(STU stu[], int *nPtr)		// 将学生从文件加载到数组 stu 的函数 load() 
{
    
	FILE *fp;
	int i;
	if((fp = fopen("student.dat", "r")) == NULL)
	{
    
		printf("No student\n");
		*nPtr = 0;
		return ;
	}
	/* 把文件中的信息全都读取到 stu 中 */
	for(i = 0; fread(&stu[i], sizeof(STU), 1, fp) != 0; i++) ;
	*nPtr = i;			/* *nPtr 记录文件中当前学生数量 */
	fclose(fp);			/* 关闭文件 */
}

void save(STU stu[], int n)			// 将数据保存到磁盘的函数 save()
{
    
	FILE *fp;
	if((fp = fopen("student.dat", "w")) == NULL)
	{
    
		printf("文件打开失败\n");
		exit(0);
	}
	fwrite(stu, n * sizeof(stu[0]), 1, fp);
	fclose(fp);
}

void output(STU stu[], int n)		// 输出所有学生信息的函数 output()
{
    
 	int i;
 	/*  打印表头 */
 	
 	printf("%8s%8s%4s%8s%8s%8s%8s%8s%8s%8s\n", "ID", "NAME", "SEX", "SCORE1", "SCORE2", "SCORE3", "SCORE4", "SCORE5",\
	 		"total", "avg");

	/*  打印所有记录 */
	for(i = 0; i < n; i++)
		PrintRecord(&stu[i]);
	system("pause");
}

void PrintRecord(STU *sPtr)			// 输出指针 sPtr所指记录的内容 
{
    
	int i;
	printf("%8s%8s%4c", sPtr->ID, sPtr->name, sPtr->sex);
	for(i = 0; i < 5; i++)
		printf("%8.2f", sPtr->score[i]);
		
	printf("%8.2f%8.2f", sPtr->total, sPtr->avg);
	printf("\n");
 } 

void add(STU stu[], int *nPtr)		// 添加记录的函数  
{
    
	int i = 0;
	char sel = 'y';
	while(sel == 'y')
	{
    
		InputRecord(stu, (*nPtr)++);	// 添加第 n+1 个学生 
		printf("是否继续添加(yes--y,no---others)\n");
		scanf(" %c", &sel);
	}
	save(stu, *nPtr);
}

void InputRecord(STU stu[], int i)		// 读入一个学生的信息,存入数组元素 stu[i] 
{
    
	int j;
	
	/* 输入学号，并验证合法性 */ 
	printf("请输入第%d个学生信息\n", i+1);
	
	printf("请输入学生学生号(学号小于9位数字组成)\n");
	scanf("%s", &stu[i].ID);
	
	/* 输入姓名 */
	printf("请输入姓名\n");
	scanf("%s", stu[i].name);
	
	printf("请输入学生性别(f 或 m [f: 代表女性 m: 代表男性])\n");
	scanf(" %c", &stu[i].sex);
	
	/* 输入5门成绩并累加 */
	printf("请输入五门课成绩(0~100)\n");
	stu[i].total = 0;
	
	for(j = 0; j < 5; j++){
    
		scanf("%f", &stu[i].score[j]); // %lf
		stu[i].total += stu[i].score[j];
	}
	
	/* 计算总成绩 */
	stu[i].avg = stu[i].total / 5;
}

void edit(STU stu[], int n)				// 修改学生信息函数 edit()
{
    
//	修改指定记录
	int i, index;
	char sel;
	char str[20];
	printf("请输入学号: \n");
	scanf("%s", str);
	
	index = FindByNum(stu, n, str);
	
	if(index < 0)
	{
    
		printf("该学生信息不存在\n");
		return ; 
	} 
	 
	printf("修改前的记录如下: \n");
	PrintRecord(&stu[index]);
	
	/*  修改姓名 */
	printf("是否修改姓名? 请输入 y or no:\n");
	scanf(" %c", &sel);
	
	if(sel == 'y')
	{
    
		printf("请输入姓名:\n");
		scanf("%s", stu[index].name);
	}
	/* 修改性别 */
	printf("是否修改性别? 输入 y or n:\n");
	scanf(" %c", &sel);
	if(sel == 'y')
	{
    
	printf("请输入 f or n:\n");
	scanf(" %c", &stu[index].name);
	}
	/* 是否修改成绩 */
	printf("是否修改成绩? input y or n:\n");
	scanf(" %c", &sel);
	if(sel == 'y')
	{
    
		stu[index].total = 0;
		
		printf("请输入5学科成绩:\n"); 
		for(i = 0; i < 5; i++){
    
			scanf("%f", &stu[index].score[i]); // %lf
			stu[index].total += stu[index].score[i];
		}
		/* 计算总成绩 */
		
		stu[index].avg = stu[index].total / 5;
	}
	save(stu, n);
 } 

/* 函数 FindByNum()按学号查找需要修改的记录，返回下标 */
int FindByNum(STU stu[], int n, char *str)
{
    
	int i;
	for(i = 0; i < n; i++)		// 若找到，返回对应下标 
		if(strcmp(stu[i].ID, str) == 0)
			return i;
	return -1;
} 

void sort(STU stu[], int n)		// 8. 排序函数sort()
{
    
	int select, i, j;
	int (*cmp)(STU a, STU b);
	
	int ScoreAsc(STU a, STU b);
	int ScoreDes(STU a, STU b);
	int NameAsc(STU a, STU b);
	
	printf("1 按总分升序排列\n");
	printf("2 安总分降序排列\n");
	printf("3 按姓名排列\n");
	scanf("%d", &select);
	switch(select)
	{
    
		case 1: cmp = ScoreAsc; break;
		case 2: cmp = ScoreDes; break;
		case 3: cmp = NameAsc; break;
		default:
			return ;
	}
	/* 按照指定规则，进行比较交换排序 */
	
	for(i = 0; i < n-1; i++)
		for(j = i+1; j < n; j++)
			if((*cmp)(stu[i], stu[j]) > 0)
			{
    
				STU temp;
				temp = stu[i];
				stu[i] = stu[j];
				stu[j] = temp;
			}
	output(stu, n);
} 

int ScoreAsc(STU a, STU b)				// 按成绩升序规则，若 a, b 逆序，返回 1 
{
    
	return a.total > b.total? 1 : -1;
}

int ScoreDes(STU a, STU b)				// 按成绩降序规则，若 a, b 逆序，返回 1 
{
    
	return a.total < b.total? 1 : -1;
 } 

int NameAsc(STU a, STU b)				// 按姓名升序规则，若 a, b逆序，返回一个 正整数 
{
    
	return strcmp(a.name, b.name);
}

void find(STU stu[], int n)				// 9 按学号查找记录的函数find() 
{
    
	int index;
	char str[20];
	
	printf("请输入学号:\n");
	scanf("%s", &str);
	index = FindByNum(stu, n, str);
	
	if(index >= 0)
		PrintRecord(&stu[index]);
	else
		printf("该学生信息不存在\n");
		
	system("pause");
}

void del(STU stu[], int *nPtr)			// 10 删除指定记录的函数 
{
    
	int i, index;
	char str[20];
	
	printf("请输入学号:\n");
	scanf("%s", str);
	index = FindByNum(stu, *nPtr, str);
	
	if(index < 0)
	{
    
		printf("\n该学生信息不存在\n");
		return ;
	}
	for(i = index; i < *nPtr-1; i++)
		stu[i] = stu[i+1];
	
	(*nPtr)--;
	printf("\n删除成功\n");
	save(stu, *nPtr);		// 保存文件 
}

int main(void) 		// int argc, char *argv[]
{
    
	STU stu[N];
	int n;
	int select;
	printf("%d------------\n", n);
	load(stu, &n);
	printf("%d------------\n", n);
	while(1)
	{
    
		display();
		scanf("%d", &select);
		switch(select)
		{
    
			case 1: add(stu, &n);	break;			// 添加
			case 2: edit(stu, n);	break;			// 修改
			case 3: sort(stu, n);	break;			// 排序
			case 4: find(stu, n);	break;			// 查找 
			case 5: del(stu, &n);	break;			// 删除
			case 6: output(stu, n);	break;			// 输出
			case 7: return 0;						// 退出 
			default: printf("菜单选择错误!!!\n"); break;
		}
	}
	return 0;
}

---

---

️Looking forward to meeting you again

---

---