PTA | C文件操作相关题目
2-1
在C语言中，读写操作时会进行自动转换的文件是
A.二进制文件和文本文件都不需要转换
B.二进制文件
C.文本文件
D.二进制文件和文本文件都需要转换
GPT
在C语言中，涉及到文件读写时的自动转换主要发生在操作文本文件时。当你在C语言中使用标准的文件操作函数（如
fopen, fread, fwrite,
fprintf, fscanf
等）来操作文本文件时，会进行某些自动转换。最常见的是换行符的转换：在Windows系统中，文本模式下的换行符通常会从
"" 转换为
""，而在写入时则会发生相反的转换。这是为了适应不同操作系统中的换行符表示差异。
相比之下，二进制文件的读写不涉及这类自动转换，因为二进制文件中的数据被视为原始字节流。
所以，正确答案是 C. 文本文件。
2-2
下面说法正确的是（ ）。
A.若文件不存在，则无法将其打开
B.文件打开后，初始读写位置总是在文件开头处
C.必须有文件指针指向已打开的文件，否则，即使打开也无法对其操作
D.一个文件关闭后，不能再次将其打开
GPT
下面对各选项进行分析：
A. 若文件不存在，则无法将其打开 - 这个说法不完全正确。在C语言中，使用
fopen() 函数打开文件时，如果文件不存在且模式是写入（例如
"w", "w+", "a", "a+"），则会创建新文件。如果是读模式（例如 "r" 或
"r+"），且文件不存在，则无法打开文件。
B. 文件打开后，初始读写位置总是在文件开头处 -
这个说法通常是正确的。在标准的C文件操作中，当使用 fopen()
函数打开文件时，初始的读写位置通常是在文件的开头，除非指定的模式会改变位置（例如追加模式
"a" 或 "a+"，初始位置会设在文件末尾）。
C. 必须有文件指针指向已打开的文件，否则，即使打开也无法对其操作 - 这个说法是正确的。在C语言中，操作文件都需要通过文件指针进行，无论是读取、写入还是其他操作。如果没有有效的文件指针，就无法对文件进行操作。
D. 一个文件关闭后，不能再次将其打开 -
这个说法不正确。文件关闭后可以再次打开，只需再次使用
fopen() 函数即可。
综上所述，正确答案是 C. 必须有文件指针指向已打开的文件，否则，即使打开也无法对其操作。
2-3
如果要打开文件fileA: - （1）若fileA不存在，则创建一个新文件； - （2）若fileA存在，打开后将文件读写指针定位于文件尾； - （3）打开后，可以读也可以写。 则打开方式应为（ ）。
A."r+"
B."w+"
C."a+"
D."ab"
GPT
根据提供的条件，我们可以确定合适的文件打开模式：
- 若
fileA不存在，则创建一个新文件； - 若
fileA存在，打开后将文件读写指针定位于文件尾； - 打开后，可以读也可以写。
这些条件最符合 "a+" 模式。在 "a+" 模式中，如果文件不存在，会创建一个新文件；如果文件已存在，打开文件并将读写指针定位在文件末尾。此外，"a+" 模式支持读和写操作。
选项分析：
- A. "r+"：打开用于更新的文件，文件必须存在。但它不满足条件（1），即不会创建不存在的文件。
- B. "w+"：打开用于读写的空文件，如果文件存在则长度截为零。这不满足条件（2），因为它会清空现有文件。
- C. "a+"：满足上述所有条件。
- D. "ab"：以二进制追加模式打开文件，仅支持写操作，不满足条件（3），即不支持读操作。
因此，正确答案是 C. "a+"。
2-4
若要打开C盘上user子目录下名为my. txt的文本文件进行读、写操作, 下面符合此要求的函数调用是()。
A.fopen("c:/user/my.txt","r+")
B.fopen("c:.txt","r+")
C.fopen("c:\user\my.txt","r+")
D.fopen("c://user//my.txt","r+")
GPT
在C语言中，文件路径中的反斜杠（）是一个特殊字符，它被用作转义字符的前缀。因此，如果你想在字符串中使用反斜杠，你需要使用两个反斜杠（\）来表示一个普通的反斜杠字符。这是因为单个反斜杠开始的组合（比如 或 可能被解释为特殊的转义序列。
根据这个规则，我们来分析给定的选项：
A. fopen("c:/user/my.txt","r+") - 这个选项使用正斜杠（/），这在许多系统中是有效的，并且在Windows中通常也能正确工作。
B. fopen("c:.txt","r+") - 这个路径使用了单个反斜杠，这可能会导致问题，因为 " 和 "" 可能会被解释为特殊的转义字符。
C. fopen("c:\user\my.txt","r+") - 这是正确的格式，在C语言中使用双反斜杠来表示文件路径。
D. fopen("c://user//my.txt","r+") - 这个选项使用了两个正斜杠，虽然这可能在某些情况下工作，但它不是标准的路径表示方式。
综上所述，正确的函数调用是 C. fopen("c:\user\my.txt","r+")。这是因为它正确地使用了双反斜杠来避免转义字符的问题，并且 "r+" 模式允许对文件进行读写操作。
2-5
在C语言中，下面关于文件操作正确的叙述是（ ）。
A.对文件操作时需要先关闭文件
B.对文件操作时打开和关闭文件的顺序没有要求
C.对文件操作时，必须先检查文件是否存在，然后再打开文件
D.对文件操作时需要先打开文件
GPT
在C语言中，文件操作的正确顺序和必要步骤是至关重要的。根据提供的选项，我们来分析哪个叙述是正确的：
A. 对文件操作时需要先关闭文件 - 这个叙述是不正确的。实际上，你必须先打开文件，然后才能进行操作，最后才关闭文件。
B. 对文件操作时打开和关闭文件的顺序没有要求 - 这个叙述也是错误的。有明确的顺序要求：首先打开文件，进行所需的操作，然后关闭文件。
C. 对文件操作时，必须先检查文件是否存在，然后再打开文件 -
这个叙述不一定正确。虽然在某些情况下你可能想要先检查文件是否存在（例如，使用
fopen 之前），但这不是必须的步骤。C语言的文件操作函数（如
fopen）本身会处理文件不存在的情况。例如，如果以读模式打开一个不存在的文件，fopen
将返回 NULL。
D. 对文件操作时需要先打开文件 -
这个叙述是正确的。在C语言中，对文件进行任何操作之前，必须先使用诸如
fopen
之类的函数打开文件。打开文件后，你可以读取、写入或修改文件，然后必须关闭文件以释放资源。
因此，正确答案是 D. 对文件操作时需要先打开文件。
2-6
FILE *fp;
int x=32;
fp=fopen("my.txt","wb");
fwrite(&x,4,1,fp);
fclose(fp);下面说法正确的是（ ）
A.my.txt保存的文件为文本文件，能够直接打开查看，文件内容为32。
B.fwrite是写文件，因此不用加&
C.my.txt虽然是文件文件，但内容是以二进制形式存储，不能直接打开查看。
D.fwrite是用于二进制的写操作，因为存储为txt文本文件，因此会转换成文本"32"，作为文本文件存储。
GPT
根据提供的代码片段，我们可以分析每个选项的正确性：
A. my.txt保存的文件为文本文件，能够直接打开查看，文件内容为32。 -
这个说法不正确。虽然文件扩展名是 .txt，但由于使用了
"wb"（写入二进制）模式，文件内容是以二进制形式存储的。32这个整数被以二进制的形式写入，而不是以可读的文本形式。
B. fwrite是写文件，因此不用加& -
这个说法也不正确。fwrite
函数需要一个指向数据的指针作为参数。在这个例子中，&x
表示取 x 的地址，即指向 x 的指针。
C. my.txt虽然是文件文件，但内容是以二进制形式存储，不能直接打开查看。
- 这个说法是正确的。文件虽然有 .txt
扩展名，但由于使用了二进制写入模式，其内容是二进制形式的，不是普通的文本格式，因此不能直接以文本编辑器打开查看。
D.
fwrite是用于二进制的写操作，因为存储为txt文本文件，因此会转换成文本"32"，作为文本文件存储。
- 这个说法不正确。fwrite
在这里是以二进制模式写入数据，不会将整数32转换为文本形式。文件的扩展名（如
.txt）对于文件内容的解释没有影响；它是以二进制格式存储的。
因此，正确答案是 C. my.txt虽然是文件文件，但内容是以二进制形式存储，不能直接打开查看。
2-7
下列语句中，把变量fp定义为一个文件指针的是__________。
A.FILE *fp;
B.FILE fp;
C.file *fp;
D.file fp;
GPT
在C语言中，文件指针是通过 FILE
类型定义的，这是标准库中定义的用于文件操作的类型。文件指针用于存储与打开文件相关的信息，包括文件位置和状态信息。
根据这一点，我们来分析各个选项：
A. FILE *fp; - 这个选项正确地定义了一个类型为 FILE
的指针。FILE
是标准I/O库中定义的类型，用于文件操作，* 表明
fp 是一个指针。
B. FILE fp; - 这个选项定义了一个 FILE
类型的变量，而不是指针。它用于直接存储文件信息，而不是存储指向该信息的指针。
C. file *fp; - 这个选项使用了小写的
file，而在C语言中，FILE
是正确的类型名称，且是区分大小写的。因此，这不是一个正确的文件指针定义。
D. file fp; - 与选项C类似，这里使用了错误的类型名称（小写的
file），而且没有使用指针。
因此，正确答案是 A. FILE *fp;，它正确地定义了一个文件指针。
2-8
进行文件操作时，“写文件”的一般含义是__________。
A.将磁盘中的信息存入计算机内存
B.将计算机内存中的信息存入磁盘
C.将计算机CPU中的信息存入磁盘
D.将磁盘中的信息存入计算机CPU
GPT
在计算机术语中，"写文件"通常指的是：
B. 将计算机内存中的信息存入磁盘
解释如下：
- 当我们说"写文件"时，这通常意味着将数据从计算机的内存（也就是程序运行时使用的临时存储空间）转移到一个更永久的存储介质上，如硬盘或SSD等。这个过程涉及到将内存中的数据复制到文件系统中，创建或修改磁盘上的文件。
其他选项的含义是：
A. 将磁盘中的信息存入计算机内存 - 这实际上描述的是"读文件"的过程，即从磁盘读取数据到内存中。
C. 将计算机CPU中的信息存入磁盘 - 这个描述不准确。CPU处理的信息通常是来自于或者存储在内存中，而不是直接与磁盘交互。
D. 将磁盘中的信息存入计算机CPU - 这同样不是写文件的过程。这更像是读取数据的描述，且实际上数据是从磁盘读入内存，而不是直接进入CPU。
因此，"写文件"的一般含义是将内存中的数据写入（存储）到磁盘上。
2-9
以读方式打开一个已有的文本文件“file1”，以下fopen()函数正确的调用方式是__________。
A.fp=fopen("file1","r");
B.fp=fopen("file1","wb");
C.fp=fopen("file1", "rb");
D.fp=fopen("file1","w");
GPT
要以读方式打开一个已有的文本文件，需要使用正确的模式字符串作为
fopen 函数的参数。下面是对各个选项的解释：
A. fp=fopen("file1","r"); - 这个选项是正确的。"r" 模式用于以读方式打开一个文本文件。如果文件存在，它可以被打开用于读取。
B. fp=fopen("file1","wb"); - 这个选项不正确。"wb" 模式用于以写方式打开一个二进制文件，并且如果文件存在，会将其内容清空。
C. fp=fopen("file1", "rb"); - 这个选项不正确。虽然 "rb" 模式用于以读方式打开一个文件，但它是针对二进制文件，而不是文本文件。
D. fp=fopen("file1","w"); - 这个选项不正确。"w" 模式用于以写方式打开一个文本文件，并且如果文件存在，也会将其内容清空。
因此，正确的调用方式，以读方式打开一个已有的文本文件“file1”，是 A. fp=fopen("file1","r");。
2-10
以下语句将输出 （）。
#include <stdio.h>
printf("%d %d %d", NULL, '\0', EOF);A.0 0 1
B.0 0 -1
C.NULL EOF
D.1 0 EOF
GPT
为了确定这段代码的输出，我们需要理解每个输出项的含义：
NULL在C语言中通常被定义为指针常量，通常是(void *)0。在使用%d格式化输出时，它通常会被视为整数0。'\0'是一个空字符，它在C语言中的数值也是0。EOF是一个在stdio.h中定义的宏，通常用于表示文件结束。它的具体值是-1。
所以，这个printf语句的输出将是：
0 0 -1
因此，正确答案是 B. 0 0 -1。
4-1
程序功能：先从键盘输入10个整数对a,b，并将其写到文本文件中；
然后，从文件中将其读出，显示在屏幕上。
存在文本文件中数据形式如下：
(2:3)
(3:4)
...注意：在下面空中填写代码时，不允许出现空格字符
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *fp;
int a, b, c, d, i, k;
fp = fopen("file1.txt", "r");
if (fp == NULL)
{
printf("打开文件失败\n");
exit(0);
}
for (i = 0; i < 10; i++)
{
scanf("%d,%d", &a, &b);
fprintf(fp, "(%d:%d)\n", a, b);
}
fclose(fp);
fp = fopen("file1.txt", "r");
if (fp == NULL)
{
printf("打开文件失败\n");
exit(0);
}
k = fscanf(fp, "(%d:%d)", &a, &b);
while (k == 2)
{
printf("%d,%d\n", a, b);
k = fscanf(fp, "(%d:%d)", &a, &b);
}
fclose(fp);
return 0;
}4-2
程序功能：从键盘依次输入学生的信息到结构体变量s_data中，再将s_data数据写到"stu.dat"文件中（stu.dat格式为二进制文件），
最后从"stu.dat"文件中读取所有学生的信息并显示。
注意：在下面空中填写代码时，不允许出现空格字符
#include <stdio.h>
#include <stdlib.h>
struct student
{
char name[9];
float score;
} s_data;
int main()
{
FILE *fp;
int i;
fp = fopen("stu.dat", "r"); // 以二进制打开文件供写
if (fp == NULL)
{
printf("File can not be opened \n");
exit(0);
}
for (i = 0; i < 10; i++)
{
scanf("%s %f", s_data.name, &s_data.score);
fwrite(&s_data, sizeof(struct student), 1, fp);
}
fclose(fp);
fp = fopen("stu.dat", "rb"); // 以只读的方式打开二进制文件
while (fread(&s_data, sizeof(s_data), 1, fp) == 1) // 成功读取一个结构体变量的数据，则循环
{
printf("姓名：%s,成绩：%6.2f：\n", s_data.name, s_data.score); // 输出结构体变量中的数据
}
fclose(fp);
return 0;
}4-3
下面程序的功能是将一个磁盘中的二进制文件复制到另一个磁盘中，两个文件名随命令行一起输入，输入时原有文件的文件名在前，新复制文件的文件名在后。请填空补全。(注意：填写时不要加额外空格)
#include <stdio.h>
int main(int argc, char *argv[])
{
FILE *old, *new;
char ch;
if (argc != 3)
{
printf("You forgot to enter a filename\n");
exit(0);
}
if ((old = fopen(argv[1], "rb")) == NULL)
{
printf("cannot open infile\n");
exit(0);
}
if ((new = fopen(argv[2], "wb")) == NULL)
{
printf("cannot open outfile\n");
exit(0);
}
while (!feof(old))
fputc(fgetc(old), new);
fclose(old);
fclose(new);
return 0;
}#include <stdio.h>
#include <stdlib.h> // 包含 exit 函数所需的头文件
int main(int argc, char *argv[]) {
FILE *old, *new;
char ch;
if (argc != 3) {
printf("You forgot to enter filenames\n");
exit(1); // 一般情况下，非零退出码表示错误
}
if ((old = fopen(argv[1], "rb")) == NULL) {
printf("Cannot open infile\n");
exit(1);
}
if ((new = fopen(argv[2], "wb")) == NULL) { // 应该使用 "wb" 模式
printf("Cannot open outfile\n");
fclose(old); // 关闭已经打开的文件
exit(1);
}
while ((ch = fgetc(old)) != EOF) { // 正确读取文件内容
fputc(ch, new);
}
fclose(old);
fclose(new);
return 0;
}
feof(old)
来检查文件结束，会在某些情况下可能导致最后一个字符被错误地读取或写入两次。
feof()
函数只有在尝试读取超出文件末尾之后才会返回真（非零值）。这意味着，如果文件读取循环在到达文件末尾之前不退出，feof()
在最后一个有效字符读取后将不会立即返回真。因此，循环可能会再执行一次，并且
fgetc(old) 会返回 EOF，但因为
feof(old) 还没有返回真，EOF 也会被写入
new 文件。
更好的做法是直接在循环中检查 fgetc(old) 的返回值。
4-4
定义了一个存储课程信息的结构体数组，从键盘输入\(n(n≤10)\)们课程信息，并将其逐个写到一个文件中去。阅读下面程序，在留空的地方填入合适的信息，使程序功能完整。
#include <stdio.h>
typedef struct _Course
{
int cNo;
char cName[30];
} COURSE;
int main()
{
int i, n;
FILE *fp;
COURSE cArr[10];
scanf("%d", &n);
if ((fp = fopen("course.dat", "wb")) == NULL)
{
printf("Can not open the file!");
exit(0);
}
for (i = 0; i < n; i++)
{
scanf("%d %s", &cArr[i].cNo, cArr[i].cName);
fwrite(&cArr[i], sizeof(COURSE), 1, fp);
}
fclose(fp);
return 0;
}6-1 显示汉字点阵图形(高级)
每个汉字的图形都由 16×16 的点阵组成，如汉字“福”的点阵图形如下：
题图.jpg
每个像素用 1 个二进制位来表示：1 表示像素是亮的，0 表示像素是不亮的。每个汉字由 16×16 = 256 个二进制位，即 32 个字节组成。
HZK16.DAT 是汉字点阵图形文件，其中包括 GB2312-80 的全部汉字图形，按汉字的区位码顺序存储。
请点击链接 HZK16.DAT 下载该文件。
请编写函数，显示汉字的图形。
函数原型
void ShowImage2(unsigned char high, unsigned char low, FILE *in, int bold, int italic);说明：参数 high 和 low
分别为汉字内码的高字节和低字节，in 是指示汉字图形库文件的指针。若参数
bold 为 1 (真)，则加粗，否则不加粗。若参数
italic 为 1
(真)，则倾斜，否则不倾斜。函数用“■”表示汉字点阵中点亮的像素，用“□”表示不亮的像素。
裁判程序
下面的程序输入汉字，输出该汉字的点阵图形。 #include <stdio.h>
#include <stdlib.h>
void ShowImage2(unsigned char high, unsigned char low, FILE *f, int bold, int italic);
int main()
{
char high, low, bold, italic;
FILE *in;
scanf(" %c%c %c %c", &high, &low, &bold, &italic);
in = fopen("HZK16.DAT", "rb");
if (!in)
{
puts("File can not open!");
exit(1);
}
ShowImage2(high, low, f, bold == 'Y', italic == 'Y');
if (fclose(in))
{
puts("File can not close!");
exit(1);
}
return 0;
}
/* 你提交的代码将被嵌在这里 */
输入格式
汉字 粗体(Y/N) 斜体(Y/N)
输出格式
指定格式的汉字
输入样例1
福 N N输出样例1
□□■□□□□□□□□□■□□□
□□□■□■■■■■■■■■□□
□□□■□□□□□□□□□□□□
□□□□□□■■■■■■■□□□
■■■■■□■□□□□□■□□□
□□□□■□■□□□□□■□□□
□□□■□□■■■■■■■□□□
□□■■■□□□□□□□□■□□
□■□■□■■■■■■■■■■□
■□□■□■□□□■□□□■□□
□□□■□■□□□■□□□■□□
□□□■□■■■■■■■■■□□
□□□■□■□□□■□□□■□□
□□□■□■□□□■□□□■□□
□□□■□■■■■■■■■■□□
□□□■□■□□□□□□□■□□实际显示效果如下：
题图.jpg
输入样例2
福 N Y输出样例2
□□■□□□□□□□□□■□□□
□□□■□■■■■■■■■■□□
□□□■□□□□□□□□□□□□
□□□□□□■■■■■■■□□□
■■■■■□■□□□□□■□□□
□□□□■□■□□□□□■□□□
□□□■□□■■■■■■■□□□
□□■■■□□□□□□□□■□□
□■□■□■■■■■■■■■■□
■□□■□■□□□■□□□■□□
□□□■□■□□□■□□□■□□
□□□■□■■■■■■■■■□□
□□□■□■□□□■□□□■□□
□□□■□■□□□■□□□■□□
□□□■□■■■■■■■■■□□
□□□■□■□□□□□□□■□□实际显示效果如下：
题图1.jpg
输入样例3
福 Y N输出样例3
□□□□■■□□□□□□□□□□□□□□□□□□■■□□□□□□
□□□□□□■■□□■■■■■■■■■■■■■■■■■■□□□□
□□□□□□■■□□□□□□□□□□□□□□□□□□□□□□□□
□□□□□□□□□□□□■■■■■■■■■■■■■■□□□□□□
■■■■■■■■■■□□■■□□□□□□□□□□■■□□□□□□
□□□□□□□□■■□□■■□□□□□□□□□□■■□□□□□□
□□□□□□■■□□□□■■■■■■■■■■■■■■□□□□□□
□□□□■■■■■■□□□□□□□□□□□□□□□□■■□□□□
□□■■□□■■□□■■■■■■■■■■■■■■■■■■■■□□
■■□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■■■■■■■■■■■■■■■■■□□□□
□□□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■■■■■■■■■■■■■■■■■□□□□
□□□□□□■■□□■■□□□□□□□□□□□□□□■■□□□□实际显示效果如下：
题图2.jpg
输入样例4
福 Y Y输出样例4
□□□□■■□□□□□□□□□□□□□□□□□□■■□□□□□□
□□□□□□■■□□■■■■■■■■■■■■■■■■■■□□□□
□□□□□□■■□□□□□□□□□□□□□□□□□□□□□□□□
□□□□□□□□□□□□■■■■■■■■■■■■■■□□□□□□
■■■■■■■■■■□□■■□□□□□□□□□□■■□□□□□□
□□□□□□□□■■□□■■□□□□□□□□□□■■□□□□□□
□□□□□□■■□□□□■■■■■■■■■■■■■■□□□□□□
□□□□■■■■■■□□□□□□□□□□□□□□□□■■□□□□
□□■■□□■■□□■■■■■■■■■■■■■■■■■■■■□□
■■□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■■■■■■■■■■■■■■■■■□□□□
□□□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■□□□□□□■■□□□□□□■■□□□□
□□□□□□■■□□■■■■■■■■■■■■■■■■■■□□□□
□□□□□□■■□□■■□□□□□□□□□□□□□□■■□□□□实际显示效果如下：
题图3.jpg
注：本题无法自测，请直接提交。
6-2 批量求和(*)
请编写函数，从一个文件中读取实数求和，并将结果写入另一个文件。
函数原型
void BatchAdd(FILE *in, FILE *out);说明：参数 in 和 out
为指示两个文件的指针。函数从 in
所指文件中的读出数据，将结果写入 out 所指的文件中。
要求：in所指文件中有很多行，每行包含两个实数，以空格间隔。函数求出这两个实数的和，写入
out 文件中，每行一个结果。
要求：输出结果保留 2 位小数。
裁判程序
#include <stdio.h>
#include <stdlib.h>
void BatchAdd(FILE *in, FILE *out);
int main()
{
FILE *in, *out;
in = fopen("Addition.txt", "r");
out = fopen("Sum.txt", "w");
if (in && out)
{
BatchAdd(in, out);
}
else
{
puts("文件无法打开!");
}
if (in)
{
fclose(in);
}
if (out)
{
fclose(out);
puts("文件保存成功!");
}
return 0;
}
/* 你提交的代码将被嵌在这里 */在程序所在文件夹中创建文本文件“Addition.txt”，复制下面的内容：
Addition.txt
25.9 8.7
120.9 87.518
12.8 65.2输入样例
(无)
输出样例
文件保存成功!程序运行结束后，打开“Sum.txt”文件，查看文件内容。
34.60
208.42
78.00Code
void BatchAdd(FILE *in, FILE *out){
double a,b;
while(fscanf(in,"%lf%lf",&a,&b)!=EOF){
fprintf(out,"%.2lf\n",a+b);
}
}6-3 有结构文件的读写1
学生类型：ST的类型定义如下：
typedef struct student{
char name[10],id[10];
int gender;
int age;
double scored;
}ST; 编写函数，从指定的文件上读入若干字符串，每行字符串是一个学生的信息（姓名，学号，性别，年龄，分数）的字符串表示，数据间以空格分隔，将学生们的信息存储于一个结构体中，并利用output()函数输出到指定文件中。
函数接口定义：
void fun(FILE *fin,FILE *fout);其中 fin 和 fout 都是用户传入的参数。
前者是已正常打开的可读文件，而后者是已正常打开的可写文件。
裁判测试程序样例：
在这里给出函数被调用进行测试的例子。例如：
#include <stdio.h>
#include <stdlib.h>
typedef struct student{
char name[10],id[10];
int gender;
int age;
double scored;
} ST;
void output(ST *d,FILE *fout){//测试程序，输出到文件调用此函数完成
if(d==NULL) {printf("null\n");return;}
fprintf(fout,"%s,%s,%d,%d,%4.2f\n",d->name,d->id,d->gender,d->age,d->scored);
}
void fun(FILE *fin,FILE *fout);//<--需要完成的函数（包括读入字符串，转换成对应的结构体，并利用函数（output（））输出到指定文件中，输入输出文件不用考虑
/* 请在这里填写答案 */输入样例：
从固定文件中读取：文件内容：
aaa 123 0 18 88.88
bbb 456 1 19 99.99
ccc 789 1 18 66.66
ddd 356 0 18 67.89输出样例：
输出到指定文件中，文件内容：
aaa,123,0,18,88.88
bbb,456,1,19,99.99
ccc,789,1,18,66.66
ddd,356,0,18,67.89Code
void fun(FILE *fin,FILE *fout){
ST st;
while(fscanf(fin,"%s%s%d%d%lf",st.name,st.id,&st.gender,&st.age,&st.scored)!=EOF){
output(&st,fout);
}
}6-4 统计成绩不及格学生信息
请编写函数，从文件中读取成绩不及格的学生信息，将结果写入另一个文件。
函数接口定义：
void FailStudent(FILE* in, FILE* out);说明：
- （1）参数in和out为指示两个文件的指针。函数从in所指文件中读出数据，将结果写入out所指的文件中。
- （2）in所指文件中有很多行(不超过100行)，每行对应一名学生的多个信息，以空格间隔，这些信息包括：学号（12位），姓名（不超过10个字符，且其中不含空格），三科成绩：数学，英语，C语言（均是<=100的非负整数）。
- （3）函数要求，某科成绩不及格（<60）的学生，需要将其“学号 姓名 该科课程名”三部分内容写入out文件中，每行一个结果。其中，三门课程的课程名分别为："Math"，"English"，"C"。
裁判测试程序样例：
#include<stdio.h>
#define MAXN 100
struct student
{
long long id;
char name[MAXN];
int score[3];
};
void FailStudent(FILE* in, FILE* out);
int main()
{
FILE *in, *out;
in = fopen("in.txt", "r");
out = fopen("out.txt", "w");
if (in && out)
{
FailStudent(in, out);
}
else
{
puts("文件无法打开!");
}
if (in)
{
fclose(in);
}
if (out)
{
fclose(out);
puts("文件保存成功!");
}
return 0;
}
/* 请在这里填写答案 */输入样例：
“in.txt”文件中保存的数据样例为：
202018010102 zhangsan 50 50 50
202026070420 hanmeimei 90 90 90
202116050331 lilei 50 90 100
202128060211 wangmazi 70 70 59输出样例：
程序运行结束后，打开“out.txt”文件，查看文件内容。
202018010102 zhangsan Math
202018010102 zhangsan English
202018010102 zhangsan C
202116050331 lilei Math
202128060211 wangmazi CCode
void FailStudent(FILE *in, FILE *out){
struct student stu;
char a[3][10]={"Math","English","C"};
while(fscanf(in,"%lld%s%d%d%d",&stu.id,stu.name,stu.score,stu.score+1,stu.score+2)!=EOF){
for(int i=0;i<3;i++){
if(stu.score[i]<60){
fprintf(out,"%lld %s %s\n",stu.id,stu.name,a[i]);
}
}
// if(stu.score[0]<60 || stu.score[1]<60 || stu.score[2]<60){
// fprintf(out,"%lld %s",stu.id,stu.name);
// if(stu.score[0]<60) fprintf(out," Math");
// if(stu.score[1]<60) fprintf(out," English");
// if(stu.score[2]<60) fprintf(out," C");
// fprintf(out,"\n");
// }
}
}