C语言期末【选择题C篇】
如若有误，欢迎各位大佬在评论区指正,谢谢
84. 设C语言中,int类型数据占2个字节,则long类型数据占©.
(A).1个字节
(B).2个字节
©.4个字节
(D).8个字节
在16位平台上：
int: 2 字节
char: 1 字节
double: 4 字节
float: 2 字节
long: 4 字节
short: 2 字节
在32位平台上：
int: 4 字节
char: 1 字节
double: 8 字节
float: 4 字节
long: 4 字节
short: 2 字节
在64位平台上：
int: 4 字节
char: 1 字节
double: 8 字节
float: 4 字节
long: 8 字节
short: 2 字节
注意:这只是一般情况下的常见设置。实际上，不同的平台和编译器可能会有所不同。此外，现代计算机的体系结构也可能使用其他位数（如64位）。通过使用 sizeof() 运算符可以准确获取特定平台和编译器下各个数据类型的字节数。
- 以下叙述正确的是©.
(A).在C程序中,main函数必须位于程序的最前面
(B).C程序的每行中只能写一条语句
©.C语言本身没有输入输出语句
(D).在对一个C程序进行编译的过程中,可发现注释中的拼写错误
86. 以下数值中,不正确的八进制数或十六进制数是©.
(A).0x16
(B).016
©.-16
(D).0xaaaa
对于选项(A)，`0x16` 是一个十六进制数，表示十进制的22，所以它是正确的。
对于选项(B)，`016` 是一个八进制数，表示十进制的14，所以它也是正确的。
对于选项(C)，`-16` 是一个十进制数，前面没有前缀表示它不是八进制或十六进制数。但是，C语言允许在整数前使用负号，所以`-16`是合法的。
对于选项(D)，`0xaaaa` 是一个十六进制数，表示十进制的65850，所以它也是正确的。
因此，不正确的八进制数或十六进制数是(C) -16。
- 已知x=43,ch=‘A’,y=0;则表达式(x>=y&&ch<‘B’&&!y)的值是©.
(A).0
(B).语法错
©.1
(D).假
已知 x=43，ch='A'，y=0。
表达式 (x>=y&&ch<'B'&&!y) 的值是 (C) 1。
根据运算符优先级，逻辑与运算符 && 的优先级高于逻辑非运算符 !，而逻辑非运算符 ! 的优先级又高于关系运算符 <，所以该表达式的计算顺序是从左到右依次计算。
首先，判断 (x>=y) 的值为真，因为 x 的值大于等于 y 的值。
其次，判断 (ch<'B') 的值也为真，因为字符 'A' 的 ASCII 码值小于字符 'B' 的 ASCII 码值。
最后，判断 (!y) 的值为真，因为 y 的值为 0 时被视为假，取反之后为真。
因此，整个表达式的值为真，即为 1。选项 (C) 1 是正确的。
- 能将高级语言编写的源程序转换为目标程序的是©.
(A).链接程序
(B).解释程序
©.编译程序
(D).编辑程序
89. 以下关于运算符优先顺序的描述中正确的是©.
(A).关系运算符<算术运算符<赋值运算符<逻辑运算符
(B).逻辑运算符<关系运算符<算术运算符<赋值运算符
©.赋值运算符<逻辑运算符<关系运算符<算术运算符
(D).算术运算符<关系运算符<赋值运算符<逻辑运算符
90. 以下叙述中不正确的是©.
(A).表达式a&=b等价于a=a&b
(B).表达式a|=b等价于a=a|b
©.表达式a!=b等价于a=a!b
(D).表达式a=b等价于a=ab
(A). `a&=b` 是按位与赋值操作。这意味着将 `a` 和 `b` 进行按位与操作，然后将结果赋值给 `a`。这确实等价于 `a=a&b`。
(B). `a|=b` 是按位或赋值操作。这意味着将 `a` 和 `b` 进行按位或操作，然后将结果赋值给 `a`。这确实等价于 `a=a|b`。
(C). `a!=b` 是不等于操作。它比较 `a` 和 `b` 是否不相等。但是，`!=` 操作本身并不执行任何赋值操作，所以 `a=a!b` 是不正确的。
(D). `a^=b` 是按位异或赋值操作。这意味着将 `a` 和 `b` 进行按位异或操作，然后将结果赋值给 `a`。这确实等价于 `a=a^b`。
根据上述分析，选项 (C) 是错误的。
- 以下不能对二维数组a进行正确初始化的语句是©.
(A).int a[2][3]={0};
(B).int a[][3]={{1,2},{0}};
©.int a[2][3]={{1,2},{3,4},{5,6}};
(D).int a[][3]={1,2,3,4,5,6};
选项 (C) 中的语句试图对已经确定大小的数组 a 进行初始化，但给出的初始值的个数和数组大小不匹配。数组 a 声明为 int a[2][3]，表示有2行3列，但提供的初始值列表包含了3个子数组，与声明的大小不匹配，因此无法正确初始化。
- 下列语句中,不正确的是C
(A).static char a[2]={1,2};
(B).static int a[2]={‘1’,‘2’};
©.static char a[2]={‘1’,‘2’,‘3’};
(D).static char a[2]={‘1’};
在选项 (C) 中，数组 a 声明为 char a[2]，表示有2个元素的字符型数组。然而，给出的初始值列表包含了3个元素：'1'、'2'、'3'，超过了数组的大小。因此，选项 (C) 不是一个正确的初始化语句。
- static struct {int a1;float a2;char a3;}a[10]={1,3.5,‘A’};说明数组a是地址常量,它有10个结构体型的下标变量,采用静态存储方式,其中被初始化的下标变量是©.
(A).a[1]
(B).a[-1]
©.a[0]
(D).a[10]
在选项中，只有 a[0] 被正确初始化，因此选项 (C) 正确。
给出的初始化语句 static struct {int a1;float a2;char a3;}a[10]={1,3.5,'A'}; 对数组 a 定义了静态存储的结构体类型数组，它包含了10个结构体类型变量，并对第一个结构体变量进行了部分初始化（第一个元素的成员 a1 被赋值为 1，成员 a2 被赋值为 3.5，成员 a3 被赋值为字符 'A'）。
由于这是一个静态数组，每个元素在编译时就已经被分配了固定的内存空间，这些元素的下标范围应该是 0 到 9，因此选项 (B) 和 (D) 都是错误的，而选项 (A) 也没有被初始化，因此也是错误的。只有选项 (C) 中的 a[0] 变量被正确初始化了。
-
以下字符中不是转义字符的是©.
(A).‘\a’
(B).‘\b’
©.‘\c’
(D).‘\’ -
以下数据中,不正确的数值或字符常量是©.
(A).0
(B).5L
©.o13
(D).9861
(A). 0 是一个合法的整型常量。
(B). 5L 表示一个长整型常量，L后缀表示长整型。这也是合法的。
(C). o13 这里的o应该是数字0，所以它应该是013。在C语言中，以0开头的数字默认为八进制，所以013表示八进制的13，即十进制的11。但是，o13并不是一个合法的表示。
(D). 9861 是一个合法的整型常量。
所以，不正确的数值或字符常量是 (C) o13。
96. 若输入ab,程序运行结果为©.
main()
{ static char a[2];
scanf(“%s”,a);
printf(“%c,%c”,a[1],a[2]);
}
(A).a,b
(B).a,
©.b,
(D).程序出错
在给定的代码中，数组 a 是一个静态字符型数组，大小为2。然后使用 scanf 函数尝试读取输入并将其存储到数组 a 中。由于 scanf 函数会自动在输入的字符串末尾添加一个空字符 '\0'，所以输入的字符串 "ab" 会存储为 "ab\0"。
在调用 printf 函数时，a[1] 表示数组 a 的第二个元素，即字符 'b'，而 a[2] 表示数组 a 的第三个元素，即空字符 '\0'。
因此，printf 函数会输出 "b,"。
因此，选项 (C) "b," 是正确的答案。
- 下列程序段的输出结果为©.
int a=7,b=9,t;
t=a*=a>b?a:b;
printf(“%d”,t);
(A).7
(B).9
©.63
(D).49
程序段中的语句 t=a*=a>b?a:b 相当于以下语句：
if (a > b) {
a = a * a;
} else {
a = b;
a = a * a;
}
t = a;
因为变量 a 的值为 7，变量 b 的值为 9，所以 a > b 不成立。因此，执行 else 分支。首先将变量 a 赋值为变量 b 的值，即 a = 9，然后再执行 a = a * a，即 a = 81。最后将变量 a 的值赋给变量 t，即 t = 81。
因此，程序的输出结果为 81，选项 (C) 是正确的。
- 下面四个选项中,均是不合法的用户标识符的选项是©.
(A).A P_0 do
(B).float la0 _A
©.b-a goto int
(D)._123 temp int
而选项 (C) 中的标识符为 b-a、goto 和 int，其中 b-a 中包含了减号 -，不符合标识符的命名规则；goto 为 C 语言中的关键字，不能作为标识符；int 也是 C 语言中的关键字，不能作为标识符。
因此，选项 (C) 中的所有标识符都是不合法的。
- 在C语言中,调用函数除函数名外,还必须有©.
(A).函数预说明
(B).实际参数
©.( )
(D).函数返回值
100. 下面判断正确的是©.
(A).char *a=“china”;等价于 char *a;*a=“china”;
(B).char str[10]={“china”};等价于char str[10];str[]={“china”};
©.char *s=“china”;等价于 char *s;s=“china”;
(D).char c[4]=“abc”,d[4]=“abc”;等价于 char c[4]=d[4]=“abc”;
(A)这个表达式是错误的。第一种方式使用指针常量来指向字符串常量，第二种方式试图将一个字符串常量赋值给一个字符指针，这是不允许的。赋值语句 char *a="china"; 等价于声明指针变量 char *a; 并将其初始化为字符串常量 "china" 的地址。而 *a="china"; 则是错误的语法，因为 *a 是指针变量 a 所指向的内存单元，而不能将字符串常量 "china" 直接赋值给该内存单元。
(B). 这个表达式也是错误的。第一种方式使用花括号来初始化字符数组，第二种方式试图省略花括号并在声明之后对其进行赋值，这是不允许的。
(C)，赋值语句 char *s="china"; 等价于声明指针变量 char *s; 并将其初始化为字符串常量 "china" 的地址。
(D)，声明语句 char c[4]="abc",d[4]="abc"; 等价于分别声明两个字符数组 c 和 d，并将它们都初始化为 "abc"。但是，这种语法不太符合 C 语言的规范，因为在同一语句中同时声明多个变量并初始化时，每个变量的类型和长度都应该显式地指定，否则编译器可能会发出警告。正确的语法应该是 char c[4]={'a','b','c','\0'}, d[4]={'a','b','c','\0'};或者 char c[] = "abc"; char d[] = "abc";。
- char *s1=“hello”,*s2;s2=s1;则©
(A).s2指向不确定的内存单元
(B).不能访问"hello"
©.puts(s1);与puts(s2);结果相同
(D).s1不能再指向其它单元
在语句 char *s1="hello",*s2;s2=s1; 中，首先声明并初始化指针变量 s1，使其指向字符串常量 "hello" 的首字符地址。然后声明指针变量 s2，将其赋值为指针变量 s1 的值，即 "hello" 字符串的首字符地址。因此，指针变量 s2 也指向 "hello" 字符串的首字符地址，可以通过指针变量 s2 访问该字符串。
由于选项 (B) 和 (D) 明显不正确，因此可以排除它们。而选项 (A) 也不正确，因为指针变量 s2 确实指向了确定的内存单元，即 "hello" 字符串的首字符地址。因此，选项 (C) 是正确的，puts(s1); 和 puts(s2); 将输出相同的结果，即 "hello"。
102. 若a是float型变量,b是unsigned型变量,以下输入语句中合法的是©.
(A).scanf(“%6.2f%d”,&a,&b);
(B).scanf(“%f%n”,&a,&b);
©.scanf(“%f%3o”,&a,&b);
(D).scanf(“%f%f”,&a,&b);
在语句 scanf("%f%3o",&a,&b); 中，使用 %f 格式说明符来读取一个浮点数并将其存储在变量 a 中，使用 %3o 格式说明符来读取一个 3 位的八进制数并将其存储在无符号整数变量 b 中。这是合法的输入语句，因为格式说明符与变量的类型匹配。
选项 (A) 是不正确的，因为 %d 格式说明符用于读取一个带符号的十进制整数，而 b 是一个无符号整数变量，类型不匹配。
选项 (B) 是不正确的，因为 %n 格式说明符用于将已读取字符的数量存储在对应的整型指针变量中，而 b 是一个无符号整数变量，类型不匹配。
选项 (D) 是不正确的，因为两次使用 %f 格式说明符来读取浮点数，而 b 是一个无符号整数变量，类型不匹配。
- C语言执行程序的开始执行点是©.
(A).程序中第一条可以执行语言
(B).程序中第一个函数
©.程序中的main函数
(D).包含文件中的第一个函数
104. fgets(str,n,fp)函数从文件中读入一个字符串,以下正确的叙述是©.
(A).字符串读入后不会自动加入’\0’
(B).fp是file类型的指针
©.fgets函数将从文件中最多读入n-1个字符
(D).fgets函数将从文件中最多读入n个字符
(A). fgets函数会自动在读入的字符串末尾添加一个'\0'作为字符串的结束符。
(B). fp是一个指向FILE类型的结构体的指针，它表示文件流，而不是一个具体的file类型的指针。
(C). 这个叙述是正确的。fgets函数将从文件中最多读入n-1个字符，并在末尾添加一个'\0'作为字符串的结束符。这个限制是为了确保读入的字符串不超过给定的缓冲区长度。
(D). fgets函数将从文件中最多读入n-1个字符，并在末尾添加一个'\0'作为字符串的结束符，所以实际上读入的字符数最多是n-1个。
- 若有说明 int a[3][4];则对a数组元素的正确引用是©.
(A).a[2][4]
(B).a[1,3]
©.a[1+1][0]
(D).a(2)(1)
(A). a[2][4] 是错误的引用。数组 a 的索引是从 0 开始的，所以最大有效索引为 a[2][3]。
(B). a[1,3] 是错误的引用。逗号运算符在这里并不起作用，实际上是等同于 a[3]。正确的引用应该是 a[1][3]。
(C). a[1+1][0] 是正确的引用。它表示数组 a 的第二行（索引为 1+1）的第一列（索引为 0）。
(D). a(2)(1) 是错误的引用。在 C 语言中，我们使用方括号 [] 而不是圆括号 () 来引用数组元素。
因此，选项 (C). a[1+1][0] 是对数组元素 a 的正确引用。
106. C程序中的宏展开是在©.
(A).编译时进行的
(B).程序执行时进行的
©.编译前预处理时进行的
(D).编辑时进行的
- 设有说明int (*ptr)[M];其中标识符ptr是©.
(A).M个指向整型变量的指针
(B).指向M个整型变量的函数指针
©.一个指向具有M个整型元素的一维数组的指针
(D).具有M个指针元素的一维指针数组,每个元素都只能指向整型量
int (*ptr)[M]中的(*ptr)表示ptr是一个指针，而[M]表示指针所指向的是具有M个元素的数组。
int (*ptr)[M]的括号是必要的，以确保优先级正确。如果没有括号，将会被解释为int *ptr[M]，这表示ptr是一个具有M个指针元素的一维指针数组。
因此，int (*ptr)[M]表示一个指针，它指向具有M个整型元素的一维数组。
总结：选项(A)、(B)和(D)都不符合int (*ptr)[M]的定义，只有选项(C)描述了正确的含义。
- 若有char a[80],*s=a;不正确的输入语句是©.
(A).scanf(“%s”,s);
(B).gets(s);
©.fscanf(stdin,“%c”,s);
(D).fgets(s,80,stdin);
选项 (A) scanf("%s", s) 是正确的，它可以用于读取字符串并将其存储到字符数组 a 中。
选项 (B) gets(s) 它也可以用于读取字符串并将其存储到字符数组 a 中。
选项 (C) fscanf(stdin, "%c", s) 是不正确的。%c 格式说明符用于读取单个字符，但 s 是一个指向字符数组的指针，而不是一个字符变量。因此，这个语句会导致未定义的行为。
选项 (D) fgets(s, 80, stdin) 是正确的，它可以用于读取一行字符串并将其存储到字符数组 a 中。
所以，不正确的输入语句是选项 (C) fscanf(stdin, "%c", s)。
109. 以下选项中合法的实型常数是©.
(A).5E2.0
(B).E-3
©…2
(D).1.3E
110. 以下常量中,能够代表逻辑"真"值的常量是©.
(A).‘\0’
(B).0
©.‘0’
(D).NULL
111. 以下标识符中,不能作为合法的C用户定义标识符的是©.
(A).putchar
(B).double
©.123
(D).INT
- 7经过以下语句定义后,表达式z+=x>y?++x:++y的值为©.
int x=1,y=2,z=3;
(A).2
(B).3
©.6
(D).5
113. 8以下运算符中优先级最低的是©.
(A).&&
(B).&
©.||
(D).|
- char a[10];不能将字符串"abc"存储在数组中的是©.
(A).strcpy(a,“abc”);
(B).a[0]=0;strcat(a,“abc”);
©.a=“abc”;
(D).int i;for(i=0;i<3;i++)a[i]=i+97;a[i]=0;
115. 在C语言中,引用数组元素时,其数组下标的数据类型允许是©.
(A).整型常量
(B).整型表达式
©.整型常量或整型表达式
(D).任何类型的表达式
- 以下各选项企图说明一种新的类型名,其中正确的是©.
(A).typedef v1 int;
(B).typedef v2=int;
©.typedef int v3;
(D).typedef v4: int;
117. 执行语句 for(i=1;i++<4;); 后变量 i 的值是©.
(A).3
(B).4
©.5
(D).不定
这个 for 循环的循环条件是 i++ < 4，也就是在每次循环开始前先判断 i 是否小于 4，如果小于则继续执行循环体，循环体结束后再执行 i++。由于循环条件中使用了后缀自增运算符，因此在判断 i 是否小于 4 之后，i 的值会自增1。
按照这个规则，可以分别分析四次循环的执行过程：
第一次循环时，i 的初值为 1，满足 i++ < 4 的条件，进入循环体执行。循环体为空，直接跳过，然后执行 i++，将 i 的值更新为 2。
第二次循环时，i 的值为 2，仍满足 i++ < 4 的条件，进入循环体执行，循环体为空，直接跳过，然后执行 i++，将 i 的值更新为 3。
第三次循环时，i 的值为 3，仍满足 i++ < 4 的条件，进入循环体执行，循环体为空，直接跳过，然后执行 i++，将 i 的值更新为 4。
第四次循环时，i 的值为 4，不再满足 i++ < 4 的条件，跳出循环。
因此，循环结束后，i 的值为 5。选项 (C). 5 是正确的答案。
118. 以下程序段的执行结果是©.
double x;x=218.82631; printf(“%-6.2e\n”,x);
(A).输出格式描述符的域宽不够,不能输出
(B).输出为21.38e+01
©.输出为2.2e+02
(D).输出为-2.14e2
“-6.2e”的意思：“6”表示输出的宽度为6个字符宽，如果整数部分超出，则按实际倍数输出。“.2”表示输出2位小数（四舍五入），不足时后面添0；对字符串，表示截取2个字符。“e”表示用指数形式输出。“-”表示在数据不足指定位数时，采用左对齐方式，即数字（字符）往左靠。默认为右对齐。
计算结果为 2.2e+02，因此选项 (C) 是正确的答案。
- 以下运算符中,优先级最高的运算符是(C ).
(A).||
(B).%
(C ).!
(D). ==
- C语言规定,在一个源程序中,main函数的位置©.
(A).必须在最开始
(B).必须在系统调用的库函数的后面
©.可以任意
(D).必须在最后
121. 当顺利执行了文件关闭操作时,fclose函数的返回值是©.
(A).-1
(B).True
©.0
(D).1
-
以下程序段中,不能正确赋字符串(编译时系统会提示错误)的是©.
(A).char s[10]=“abcdefg”;
(B).char t[]=“abcdefg”,*s=t;
©.char s[10];s=“abcdefg”;
(D).char s[10];strcpy(s,“abcdefg”); -
在C语言中,函数的隐含存储类别是©.
(A).auto
(B).static
©.extern
(D).无存储类别
124. 若已定义x为int类型变量,下列语句中说明指针变量p的正确语句是(C ).
(A).int p=&x;
(B).int *p=x;
(C ).int *p=&x;
(D).*p=*x;
在定义指针变量时，需要使用 * 符号指定该变量为指针类型，并使用 & 符号获取变量的地址。
(A). int p=&x; 表示将 x 的地址赋值给 p，这是错误的，因为 p 应该是一个指针变量，而不是整型变量。
(B). int *p=x; 表示将 x 的值直接赋值给 p，这也是错误的，应该赋值 x 的地址给 p。
(C). int *p=&x; 正确地将 x 的地址赋值给了指针变量 p。
(D). *p=*x; 这个语句是错误的，因为 *p 表示 p 指向的内存位置的值，而 *x 则表示 x 的值，两者都应该是指针类型才能进行赋值操作。
因此，选项 (C). int *p=&x; 是正确的语句。
125. 切换编辑窗和信息窗的命令键是(C ).
(A).F2
(B).F3
(C ).F6
(D).F9
- 在以下给出的表达式中,与 do–while(E)语句中的(E)不等价的表达式是©.
A).(!E == 0)
(B).(E>0||E<0)
©.(E == 0)
(D).(E!=0)
do-while 语句会先执行一次循环体，然后再进行条件判断。因此，在 do--while(E) 中，E 表示的是循环条件，即当 E 不为 0 时继续循环，否则退出循环。
根据这个含义，可以对选项进行分析：
(A). (!E == 0)：!E 表示 E 的逻辑反，也就是当 E 为 0 时结果为真，否则为假。将其与 0 进行比较，相当于将 E 的逻辑值转换为整型值。因此，选项 A 等价于 (E == 0)，与原表达式不等价。
(B). (E > 0 || E < 0)：表示当 E 大于 0 或小于 0 时为真，相当于 E 不为 0 时为真，与原表达式等价。
(C). (E == 0)：表示当 E 等于 0 时为真，与原表达式不等价。
(D). (E != 0)：表示当 E 不等于 0 时为真，与原表达式等价。
因此，与 do--while(E)语句中的(E)不等价的表达式是 (C). (E == 0)。
- 用下列语句定义a,b,c,然后执行b=a、c=‘b’+b,则b,c的值是©.
long a=0xffffff;
int b; char c;
(A).0ffffff 和0x61
(B).-1和98
©.-1和97
(D).指向同一地址
根据给定的语句：
long a = 0xffffff; 定义了一个 long 类型的变量 a，并赋值为十六进制数 0xffffff，相当于十进制数的 -1。
int b; 定义了一个 int 类型的变量 b，没有进行初始化赋值。
char c; 定义了一个 char 类型的变量 c，没有进行初始化赋值。
接下来执行语句：
b = a; 将变量 a 的值赋给变量 b。由于 a 的值为 -1，将其转换为 int 类型后仍然是 -1，因此 b 的值为 -1。
c = 'b' + b; 将字符 'b' 与变量 b 的值相加，并将结果赋给变量 c。字符 'b' 的 ASCII 码为 98，而 b 的值为 -1。在字符与整型相加时，会将字符转换为对应的 ASCII 码，然后进行相加。因此，'b' + (-1) 的结果为 97，即字符 'a' 的 ASCII 码。将该值赋给 c，所以 c 的值为 97。
因此，b 的值为 -1，c 的值为 97。选项 (C). -1 和 97 是正确的答案。
-
以下对二维数组a的正确说明是©.
A).int a[3][]
(B).float a(3,4)
©.double a[1][4]
(D).float a(3)(4) -
在C语言的函数中,下列正确的说法是©.
(A).必须有形参
(B).形参必须是变量名
©.可以有也可以没有形参
(D).数组名不能作形参 -
char *s1=“hello”,*s2;s2=s1;则©.
(A).s2指向不确定的内存单元
(B).不能访问"hello"
©.puts(s1);与puts(s2);结果相同
(D).s1不能再指向其它单元 -
以下不正确的if语句形式是©.
(A).if(x>y&&x!=y);
(B).if(x==y) x+=y;
©.if(x!=y) scanf(“%d”,&x) else scanf(“%d”,&y);
(D).if(x
(C) if(x!=y) scanf("%d",&x)漏分号else scanf("%d",&y);