全国计算机二级C语言 # 选择题:结构体、共用体与文件(1-38)
1. 若文件指针fp已指向打开的文件，则以下关于fclose(fp)函数的叙述正确的是答案：D
A）只有对文件进行写操作之后，才需要调用fclose(fp)函数关闭文件
B）当程序中对文件的所有写操作完成之后，不一定要调用fclose(fp)函数关闭文件
C）只有对文件进行读操作之后，才需要调用fclose(fp)函数关闭文件
D）当程序中对文件的所有写操作完成之后，必须调用fclose(fp)函数关闭文件
题目解析:完成对文件的操作后，必须要关闭当前文件，以免文件数据的丢失，而且fopen(文件名, fp)与fclose(fp)必须成对出现，不管对该文件有没有进行对操作。
2. 标准库函数fgets( s,n,f )的功能是答案：B
A）从文件f中读取长度为n的字符串存入指针s所指的内存
B）从文件f中读取长度不超过n-1的字符串存入指针s所指的内存
C）从文件f中读取n-1个字符串存入指针s所指的内存
D）从文件f中读取n个字符串存入指针s所指的内存
题目解析:函数fgets(s,n,f)的功能是从f指向的文件中读取一个长度为n-1的字符串，将其存入s指向的存储区中。
3. 有以下程序
#include <stdio.h>
typedef struct{
char name[10];
int age;
} ST;
main()
{ ST stud[10]={ “Adum”, 15,
“Muty”, 16,
“Paul”, 17,
“Johu”, 14,
};
}
程序运行时不能输出字符u的语句是答案：D
A）printf(“%c “, stud[1].name[1] );
B）printf(“%c “, stud[3].name[3] );
C）printf(“%c “, stud[2].name[2] );
D）printf(“%c “, stud[0].name[3] );
4. 以下叙述正确的是答案：B
A）EOF只能作为二进制文件的结束标志
B）EOF只能作为文本文件的结束标志，其值为-1
C）EOF可以作为所有文件的结束标志
D）任何文件都不能用EOF作为文件的结束标志
题目解析:EOF为一符号常量，值为-1，在C语言中常被作为文本文件的结束标志，不能作为二进制文件的结束标志。
5. 以下叙述正确的是答案：D
A）fopen函数的调用形式为：fopen(文件名)
B）fopen函数的返回值必须赋给一个任意类型的指针变量
C）fopen函数的返回值为NULL时，则成功打开指定的文件
D）在C语言中调用fopen函数就可把程序中要读、写的文件与磁盘上实际的数据文件联系起来
题目解析:fopen()函数的调用格式为：”文件指针名=fopen(文件名,使用文件方式)”将文件指针指向磁盘上实际的文件地址，返回非NULL时才是成功打开指定的文件，文件指针必须为FILE类型的指针。
6. 以下不能对文件进行输出的库函数是答案：D
A）fwrite
B）fprintf
C）fputc
D）fread
题目解析:对文件进行输出的库函数有fprintf、fputc、fputs、fwrite等，没有名为fpout的函数。
7. 设有以下程序段
struct person
{
char name[10];
char sex;
float weight;
} zhangsan, *ptr;
ptr = &zhangsan;
若要从键盘读入姓名给结构体变量zhangsan的name成员，以下选项中错误的是答案：C
A）scanf(“%s”, ptr->name);
B）scanf(“%s”, (*ptr).name);
C）scanf(“%s”, zhangsan->name);
D）scanf(“%s”, zhangsan.name);
题目解析:结构体变量对其成员变量的引用用”.”运算符，而结构体指针引用成员变量使用指向运算符”->”，选项D）对name这一成员变量的引用有错，应该使用”.”运算符。
8. 有如下程序
#include <stdio.h>
struct person
{
char name[10];
int age;
}
main()
{
struct person room[4] = {{“Zhang”, 19}, {“Li”, 20}, {“Wang”, 17}, {“Zhao”, 18}};
printf(“%s:%d “, (room+2)->name, room->age);
}
程序运行后的输出结果是答案：C
A）Li:20
B）Wang:17
C）Wang:19
D）Li:19
题目解析:结构体为用户自定义的一种构造类型，其用法和C语言基本数据类型一致，所以(room+2)->name与room[2].name等价，room->age与room[0].age等价，输出结果为Wang:19。
9. 有如下程序
#include <stdio.h>
struct pair
{
int first, second;
};
struct pair get_min_max(int* array, int len)
{
int i;
struct pair res;
res.first = array[0];
res.second = array[0];
for (i=1; i<len; i++)
{
if (array[i] < res.first)
res.first = array[i];
if (array[i] > res.second)
res.second = array[i];
}
return res;
}
main()
{
int array[5] = {9, 1, 3, 4};
struct pair min_max = get_min_max(array, 5);
printf(“min=%d,max=%d “, min_max.first, min_max.second);
}
程序运行后的输出结果是答案：A
A）min=0,max=9
B）min=1,max=9
C）min=1,max=4
D）min=0,max=4
题目解析:函数get_min_max()的作用是计算数组array中前n个数据的最大值和最小值，将其记录在结构体变量res中并返回，数组array[5]不完全赋值，没有赋初值的a[4]设为默认值0，所以计算得的最小值和最大值分别为0和9。
10. 以下选项中叙述正确的是答案：D
A）文件指针的值是文件在计算机磁盘中的路径信息
B）文件指针可同时指向不同文件
C）调用fscanf函数可以向文本文件中写入任意字符
D）文件指针是指针类型的变量
题目解析:文件指针是FILE类型的指针变量；使用fopen()函数只能把文件指针和一个文件建立联系；文件指针是一个指针，存储的是FILE结构体的地址；fscanf()函数用于从文件中读取数据。
11. 有如下程序
#include <stdio.h>
struct S
{
int x, y;
};
main()
{
struct S data[2] = {4, 3, 1, 9};
int i;
for (i=0; i<2; i++)
printf(“%d,%d;”, data[i].x, data[i].y >> 1);
printf(” “);
}
程序运行后的输出结果是答案：A
A）4,1;1,4;
B）4,3;2,3;
C）4,1;2,4;
D）4,3;1,9;
题目解析:结构体为用户自定义的一种构造类型，其用法和C语言基本数据类型一致，所以data[0].x的值为4，data[0].y的值为3，对应ASCII码值为0011，0011>>1=0001，对应十进制数值为1；data[1].x的值为1，data[0].y的值为9，对应ASCII码值为1001，1001>>1=0100，对应十进制数值为4。
12. 有如下程序
#include <stdio.h>
#include <string.h>
struct S
{
char name[10];
};
void change(struct S *data, int value)
{
strcpy(data->name, “****”);
value = 13;
}
main()
{
struct S input;
int num = 4;
strcpy(input.name, “THIS”);
change(&input, num);
printf(“%s,%d “, input.name, num);
}
程序运行后的输出结果是答案：D
A）****,13
B）THIS,13
C）THIS,4
D）****,4
题目解析:函数change()的第一个参数为结构体变量地址作为函数参数，为地址传参，形参和实参指向的为同一块内存地址，所以对数组元素的改变能够影响到实参。语句”strcpy(data->name, “**** “);”则将data指向的结构体变量中的name值变为”****”；函数change()的第二个参数为值传参，所以对num的值没有改变，输出结果为4。
13. 有如下程序
#include <stdio.h>
#include <string.h>
struct S
{
char name[10];
};
main()
{
struct S s1, s2;
strcpy(s1.name, “12345”);
strcpy(s2.name, “ABC”);
s1 = s2;
printf(“%s “, s1.name);
}
程序运行后的输出结果是答案：A
A）ABC
B）12345
C）ABC45
D）ABC12
题目解析:同类型的结构体变量之间可以直接赋值。
14. 有如下程序
#include <stdio.h>
main()
{
int i;
FILE* fp;
for (i=0; i<5; i++)
{
fp = fopen(“output.txt”, “w”);
fputc(‘A’ + i, fp);
fclose(fp);
}
}
程序运行后，在当前目录下会生成一个output.txt文件，其内容是答案：B
A）ABCDE
B）E
C）A
D）EOF
题目解析:文件以只写方式打开”w”，打开已存在的文件时会把文件长度清零，所以最终写入文件的为字符′A′+4，即′E′。
15. 设有定义：struct { int n; float x;} s[2],m[2]={{10,2.8},{0,0.0}};
则以下赋值语句中正确的是答案：C
A）s[2].x=m[2].x;
C）s[0]=m[1];
题目解析:同类型的结构体变量之间可以直接赋值但是数组却不可以，选项B）错误；结构体的数组名仍然为一指针常量，引用其成员变量的时候要使用指向运算符”->”，选项C）错误；数组的下标的下限为0，上限为n-1，其中n为数组的维数，选项A）引用数组越界，错误。
16. 有以下程序
#include <stdio.h>
#include <string.h>
typedef struct {
char name[10];
char sex;
int age;} STU;
void fun(STU *t)
{ strcpy((*t).name,”Tong”);
(*t).age++;
}
main()
{ STU s[2]={“Hua”,’m’,18,”Qin”,’f’,19};
fun(s+1);
printf(“%s,%d,%s,%d “,s[0].name,s[0].age,s[1].name ,s[1].age );
}
程序运行后的输出结果是答案：D
A）Hua,19,Tong,19
B）Hua,18,Qin,19
C）Tong,19,Qin,19
D）Hua,18,Tong,20
题目解析:结构体数组名作为函数参数为地址传参，函数fun()的作用是把当前指针指向的结构体变量中的name赋值为”Tong”，并让成员变量age自增1，调用函数时传递的是数组第二个元素的地址，所以改变的是第二个元素的值。
17. 有以下程序段
FILE *fp;
if( (fp=fopen(“test.txt”，”w”)) == NULL)
{ printf(“不能打开文件！”);
exit(0);}
else
printf(“成功打开文件！”);
若指定文件test.txt不存在，且无其他异常，则以下叙述错误的是答案：B
A）系统将按指定文件名新建文件
B）输出”不能打开文件！”
C）输出”成功打开文件！”
D）系统将为写而建立文本文件
题目解析:若指定的文件不存在，则文件打开失败，函数fopen()返回指针为空（NULL），执行选择结构的if支句，输出”不能打开文件！”。
19. 设有如下定义
struct{ int n; char c; } a[2],*p=a;
则以下错误引用结构体成员n的是答案：A
A）(*a)->n
B）(*p).n
C）a[0].n
D）p->n
题目解析:结构体变量对其成员变量的引用用”.”运算符，而结构体指针引用成员变量使用指向运算符”->”，(*a)与a[0]等价，引用成员变量n应该使用”.”运算符
20. 有以下程序
#include <stdio.h>
#include <string.h>
typedef struct {
char name[10];
char sex;
int age;
} STU;
void fun(STU t)
{ strcpy(t.name,”Tong”);
t.age++;
}
main()
{ STU s[2]={“Hua”,’m’,18,”Qin”,’f’,19};
fun(s[1]);
printf(“%s,%d,%s,%d “,s[0].name,s[0].age,s[1].name ,s[1].age );
}
程序运行后的输出结果是答案：B
A）Hua,18,Tong,20
B）Hua,18,Qin,19
C）Tong,19,Qin,19
D）Hua,19,Tong,19
题目解析:结构体变量名作为函数参数是值传递，形参数据的改变不会影响到实参数据，所以函数调用结束后数组s中的数据没有变化
21. 有以下程序段
FILE *fp;
if( (fp=fopen(“test.txt”，”w”)) == NULL)
{ printf(“不能打开文件！”);
exit(0);}
else
printf(“成功打开文件！”);
若文件test.txt已存在，则以下叙述正确的是答案：C
A）对文件test.txt写入的内容总是被添加到文件尾部
B）程序运行时，会因文件存在而出错
C）程序运行后，文件test.txt中的原有内容将全部消失
D）对文件test.txt进行写操作后，可以随机进行读取
题目解析:文件以只写方式打开”w”，若成功打开已存在的文件时会把文件长度清零，即文件中的原有的内容会全部消失
22. 有以下程序
#include <stdio.h>
main( )
{ FILE *fp;
int i, a[6] = {1,2,3,4,5,6}, k;
fp = fopen(“data.dat”, “w+”);
fprintf(fp, “%d “, a[0]);
for (i=1; i<6; i++)
{ rewind(fp);
fprintf(fp, “%d “, a[i]);
}
rewind(fp);
fscanf(fp, “%d”, &k);
fclose(fp);
printf(“%d “, k);
}
程序运行后的输出结果是答案：C
A）123456
B）654321
C）6
D）21
题目解析:该段代码以写的方式”w+”打开二进制文件data.dat，语句”fseek(fp, 0L, 0);”和”rewind(fp)”的作用是将文件指针移动至文件首。代码作用是将数组a中的元素写入文件，并统计元素个数，即6。
23. 有以下程序
#include <stdio.h>
typedef struct stu {
char name[10];
char gender;
int score;
} STU;
void f(STU a, STU *b)
{ a = *b;
printf(“%s,%c,%d,”, a.name, a.gender, a.score);
}
main( )
{ STU a = {“Zhao”, ‘m’, 290}, b = {“Qian”, ‘f’, 350};
f(a,&b);
printf(“%s,%c,%d “, a.name, a.gender, a.score);
}
程序运行后的输出结果是答案：A
A）Qian,f,350,Zhao,m,290
B）Zhao,m,290,Qian,f,350
C）Qian,f,350,Qian,f,350
D）Zhao,m,290,Zhao,m,290
题目解析:同类型的结构体之间可以直接赋值，函数f()中把结构体变量b中的数据整体赋值给了结构体变量a，所以第一次输出为Qian,f,350；函数f()传递的参数为结构体变量，也是一种值传参，形参的变化不能影响到实参，所以主函数中调用函数f(a,&b)对a中的数据没有影响，即输出Zhao,m,290。
24. 有以下程序
#include <stdio.h>
main( )
{ FILE *fp;
int i, a[6] = {1,2,3,4,5,6}, k;
fp = fopen(“data.dat”, “w+b”);
fwrite(&a[0], sizeof(int), 1, fp);
for (i=1; i<6; i++)
{
fseek(fp, 0L, 0);
fwrite(&a[i], sizeof(int), 1, fp);
}
fseek(fp, 0L, 0);
fread(&k, sizeof(int), 1, fp);
fclose(fp);
printf(“%d “, k);
}
程序运行后的输出结果是答案：A
A）6
B）21
C）123456
D）654321
题目解析:该段代码以读写的方式”wb+”打开二进制文件data.dat，并将数组a的第一个元素写入文件，接下来的for循环是用fread()函数不断读取当前文件中的数据，将该数据和数组a的下一个元素累加后又用fwrite()函数写入到文件当中（语句”fseek(fp, 0L, 0);”和”rewind(fp)”的作用是将文件指针移动至文件首），k记录的是数组中有多少元素个数。所以输出为6。
25. 设有以下程序段
struct person
{
float weight;
char sex;
char name[10];
} rec, *ptr;
ptr = &rec;
若要从键盘读入字符串给结构体变量rec的name成员，以下输入语句错误的是答案：D
A）scanf(“%s”, rec.name);
B）scanf(“%s”, (*ptr).name);
C）scanf(“%s”, ptr->name);
D）scanf(“%s”, rec->name);
题目解析:结构体变量对其成员变量的引用用”.”运算符，而结构体指针引用成员变量使用指向运算符”->”。
26. 有如下程序
#include <stdio.h>
struct person
{
char name[10];
int age;
};
main( )
{
struct person room[2] = {{“Wang”, 19}, {“Li”, 20}};
printf(“%s:%d “, (room+1)->name, room->age);
}
程序运行后的输出结果是答案：D
A）Wang:19
B）Li:20
C）Wang:17
D）Li:19
题目解析:结构体为用户自定义的一种构造类型，其用法和C语言基本数据类型一致，所以(room+1)->name和room[2].name等价，room->age与room[0].age等价，即输出为Li:19。
27. 有如下程序
#include <stdio.h>
main( )
{
int a = 9, b;
b = (a >> 3) % 4;
printf(“%d,%d “, a, b);
}
程序运行后的输出结果是答案：A
A）9,1
B）9,3
C）4,0
D）4,3
题目解析:十进制数9转化为二进制数为1001,1001>>3的结果化为十进制为1,1%4的结果为1，所以b=1，a=9。
28. 以下叙述正确的是答案：B
A）文件指针变量的值是文件在当前读取位置处数据的值
B）文件指针是指针类型的变量
C）文件指针变量的值是文件的当前读取位置
D）调用fscanf函数能向所有类型的文件中写入任意字符
题目解析:文件指针是FILE类型的指针变量；文件指针是一个指针，存储的是FILE结构体的地址；fscanf()函数用于从文件中读取数据。
29. 有以下程序
#include <stdio.h>
struct S
{
int x, y;
};
main( )
{
struct S data[3] = {4, 3, 2, 0, 8, 1};
int i;
for (i=0; i<3; i++)
printf(“%d%d;”, data[i].x, data[i].y >> 1);
printf(” “);
}
程序运行后的输出结果是答案：B
A）43;20;81;
B）41;20;80;
C）41;22;64;
D）40;21;80;
题目解析:结构体为用户自定义的一种构造类型，其用法和C语言基本数据类型一致，所以data[0].x的值为4，data[0].y的值为3，对应ASCII码值为0011，0011>>1=0001，对应十进制数值为1；data[1].x的值为2，data[1].y的值为0，对应ASCII码值为0000，0000>>1=0000，对应十进制数值为0；data[2].x的值为8，data[2].y的值为1，对应ASCII码值为0001，0001>>1=0000，对应十进制数值为0，所以输出为41；20；80
30. 有以下程序
#include <stdio.h>
#include <string.h>
struct S
{
char name[10];
};
void change(struct S *data, int value)
{
strcpy(data->name, “#”);
value = 6;
}
main( )
{
struct S input;
int num = 3;
strcpy(input.name, “OK”);
change(&input, num);
printf(“%s,%d “, input.name, num);
}
程序运行后的输出结果是答案：D
A）OK,6
B）OK,3
C）#,6
D）#,3
题目解析:函数change()的第一个参数为结构体变量地址作为函数参数，为地址传参，形参和实参指向的为同一块内存地址，所以对数组元素的改变能够影响到实参。语句”strcpy(data->name, “# “);”则将data指向的结构体变量中的name值变为”#”；函数change()的第二个参数为值传参，所以对num的值没有改变，输出结果为3。
31. 有以下程序
#include <stdio.h>
#include <string.h>
struct S
{
char name[10];
};
main()
{
struct S s1, s2;
strcpy(s1.name, “XXX”);
strcpy(s2.name, “=”);
s1 = s2;
printf(“%s “, s1.name);
}
程序运行后的输出结果是答案：D
A）=XX
B）X=
C）XXX
D）=
题目解析:同类型的结构体变量之间可以直接赋值。
32. 有以下程序
#include <stdio.h>
main( )
{
int i;
FILE* fp;
for (i=0; i<3; i++)
{
fp = fopen(“res.txt”, “w”);
fputc(‘K’ + i, fp);
fclose(fp);
}
}
程序运行后，在当前目录下会生成一个名为res.txt的文件，其内容是答案：A
A）M
B）KLM
C）EOF
D）L
题目解析:文件以只写方式打开”w”，打开已存在的文件时会把文件长度清零，所以最终写入文件的为字符′K′+4，即′M′。
33. 以下关于C语言文件系统的叙述中正确的是答案：B
A）fscanf()与fread()函数功能相同
B）以”w”或”wb”方式打开的文件，不可以从中读取数据
C）fprintf()与fwrite()函数功能相同
D）文件以”r”方式打开后，可以存储文本类型的数据
题目解析:fscanf()函数用于从文件中读取数据；fread经常被用在对二进制文件的读入函数；fprintf()的功能是将内存中的数据转换成对应的字符，并以ASCII代码形式输出到文本文件中；函数fwrite()的功能是将数据写入二进制文件；”w”或”wb”方式代表写入文件数据，r以只读方式打开文本文件。r方式表示只读
34. 设有定义
#include <stdio.h>
#include <stdlib.h>
typedef struct{ int x,y; } T;
typedef struct{ int x,y; } *USER;
USER fun( )
{ USER p;
p=(USER)malloc(sizeof(T));
p->x=1;
p->y=2;
return p;
}
函数fun返回值的类型是答案：C
A）int类型的元素
B）T类型的结构体
C）指向结构体类型的指针
D）int类型的指针
题目解析:语句”malloc( sizeof( T ))”为动态分配了一块内存，返回的是一个指针p，由于USER是一个结构体，所以指针p指向的是结构体类型，故本题答案选C）。
35. 函数filecopy的功能是，将fin所指文件中的内容输出到fout所指文件中，但函数不完整：
void filecopy( FILE *fin,FILE *fout)
{ char ch;
ch=getc(fin);
while(________________)
{ putc(ch,fout);
ch=getc(fin);
}
}
其中下划线处应填入的是答案：D
A）feof(fout)==1
B）!feof(fout)
C）feof(fin)==1
D）!feof(fin)
题目解析:feof是C语言标准库函数，其原型在stdio.h中，其功能是检测流上的文件结束符，如果文件结束，则返回非0值，否则返回0，文件结束符只能被clearerr()清除。需要进行的判断是文件fin不结束，即前面加一个感叹号。
36. 有下列程序
#include <stdio.h>
main( )
{ FILE *fp;
int i, a[6] = {1,2,3,4,5,6};
fp = fopen(“d.dat”, “w+b”);
for(i=5; i>=0; i–)
fwrite(&a[i], sizeof(int), 1, fp);
rewind(fp);
fread(a, sizeof(int), 3, fp);
fclose(fp);
for (i=0; i<6; i++)
printf(“%d,”, a[i]);
}
程序执行后的输出结果是答案：B
A）6,5,4,3,2,1,
B）6,5,4,4,5,6,
C）1,2,3,4,5,6,
D）1,2,3,3,2,1
题目解析:以读写的方式”w+b”打开二进制文件d.dat。for循环中利用fwrite函数将数据写入文件（最终文件d中的数据是6、5、4、3、2、1），函数返回的是写入数据的个数，fwrite()后必须关闭流fclose()。不关闭流的情况下，每次读或写数据后，文件指针都会指向下一个待写或者读数据位置的指针。fread函数返回读取数据的个数，通过fread函数将文件d中的前3个数据赋值至a[0]、a[1]和a[2]，最终数组a中的值变为{6,5,4,4,5,6}，故本题答案为B）。
37. 设有以下程序段
struct person
{
char Name[10];
float Weight;
} stu, *ptr;
ptr = &stu;
若要从键盘读入一行字符串（字符个数小于8）赋给结构体变量stu的Name成员，以下选项中写法错误的是答案：B
A）scanf(“%s”, ptr->Name);
B）scanf(“%s”, stu->Name);
C）scanf(“%s”, stu.Name);
D）scanf(“%s”, (*ptr).Name);
题目解析:scanf(“%s”, stu->Name)应改为scanf(“%s”, ptr->Name)
38. 下面说法正确的是答案：A
A）文件指针是指针类型的变量
B）文件指针的值是文件的长度（以字节为单位）
C）文件指针的值是文件名字符串存放的首地址
D）fscanf函数可以向任意指定文件中写入任意指定字符
题目解析:fsacnf函数可以将字符输入至指定文件，由于读写方式的不同，这种字符和文件受条件的约束，在C语言中用一个指针变量指向一个文件，这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作。文件指针的值是其所指向的文件。
本章结束，选择题结束。
