试卷01
单选题
1.已知int a[][3] = { { 0, 1 }, { 2, 3, 4 }, { 5, 6 }, { 7 } };，则a[2][1]的值是（）
A0 B2 C6 D7
正确答案：C
官方解析：在这段C语言代码中，定义了一个二维数组a,第一个维度未指定大小(由初始化的数据决定),第二个维度指定为3。通过初始化列表可知数组包含4行。根据C语言规则,如果初始化数据不足,剩余元素会被自动初始化为0。
让我们分析每一行的实际值:
第一行 {0,1,0} - 第三个元素自动补0
第二行 {2,3,4} - 完整初始化
第三行 {5,6,0} - 第三个元素自动补0
第四行 {7,0,0} - 第二、三个元素自动补0
所以a[2][1]表示第三行(下标从0开始)的第二个元素,即为6。因此C选项正确。
分析其他选项:
A(0)错误:0是第一行第一个元素a[0][0]的值
B(2)错误:2是第二行第一个元素a[1][0]的值
D(7)错误:7是第四行第一个元素a[3][0]的值
这道题目考察了:
C语言二维数组的初始化规则
数组下标从0开始计数的特点
数组部分初始化时,未显式初始化的元素自动补0的规则
2.C 语言俗称"低级语言的高级形式"，这说明C 语言的功能不强。请问这句话的说法是正确的吗？
A正确 B错误
正确答案：B
官方解析："C语言俗称'低级语言的高级形式'"这句话并不表示C语言功能不强，恰恰相反。
C语言被称为"低级语言的高级形式"是因为它既具有高级语言的特点（如良好的可读性、可移植性和结构化程序设计能力），又保留了低级语言的特性（如直接操作内存、指针运算、接近硬件等）。这正是C语言强大的体现：
- 高级语言特性：
具有丰富的数据类型和控制结构
支持结构化程序设计
有较强的可读性和可维护性
具有良好的可移植性
- 低级语言特性：
能直接访问和操作内存
支持指针运算
可以直接进行位操作
能够开发系统软件和驱动程序
A选项错误。将"低级语言的高级形式"理解为功能不强是对这个描述的误解。实际上，C语言的这种特性使它在系统编程、嵌入式开发等领域有着不可替代的地位。
因此，B选项是正确的。这种特性恰恰体现了C语言的强大功能。
3.switch(c)语句中，c不可以是什么类型（）
Aint Blong Cchar Dfloat
正确答案：D
官方解析：switch语句中的判断条件表达式类型是有限制的。float(浮点型)是不允许作为switch语句的判断条件的。
switch语句的case分支必须是常量且能在编译时确定其值。因为switch语句在编译时会转换为一个跳转表,要求能够精确定位每个case分支的位置。而浮点数由于其存储特性和精度问题,无法保证完全准确的比较,所以不能用作switch的判断条件。
分析其他选项:
A正确:int(整型)可以作为switch的判断条件
B错误但不是正确答案:long类型也不能作为switch的判断条件,因为long的取值范围太大
C正确:char(字符型)可以作为switch的判断条件,因为char本质上是16位无符号整数
在Java中,switch语句支持的数据类型包括:
byte,short,char,int
从Java 7开始支持String
枚举类型(enum)
所以float类型确实不能用作switch语句的判断条件,D是正确答案。
4.用printf函数输出一个字符串时，格式字符为%s，输出项可以是此字符串或存放此字符串的数组的数组名。请问这句话的说法是正确的吗？
A正确 B错误
正确答案：A
官方解析：这道题考察printf函数输出字符串的基本知识。题目中的说法是正确的,所以A选项是对的。
在C语言中,使用printf函数输出字符串时：
格式控制符%s用于输出字符串
输出项可以是:
字符串常量 如printf("%s", "Hello")
字符数组名 如char str[] = "Hello"; printf("%s", str)
字符指针 如char *p = "Hello"; printf("%s", p)
这是因为字符串在内存中的存储方式决定的:
字符串常量直接存储在内存中
字符数组名表示数组的首地址,也就是字符串的起始位置
字符指针指向字符串的首地址
printf函数通过%s可以从给定的地址开始,一直输出到遇到''(字符串结束符)为止。因此无论是直接给出字符串,还是给出存储字符串的数组名,都能正确输出字符串内容。
选项B错误,因为题目描述完全符合printf函数输出字符串的实际使用规则。
5.下列程序的输出结果是
|-------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 |#include <iostream>usingnamespacestd;voidf() {``staticinti = 15;``i++;``cout << ``"i="<< i << endl;}intmain(``void``){``for``(``intk = 0;k < 2;k++)``f();}|Ai=16 i=15 Bi=15 i=17 Ci=16 i=17 Di=15 i=16 Ei=15 i=18
正确答案：C
官方解析：这道题目主要考察static关键字的特性和作用。在程序中,函数f()中声明了一个静态局部变量i,初始值为15。static变量的特点是在程序运行期间只初始化一次,而且其值在函数调用结束后仍然保持。
让我们分析程序执行过程:
- 第一次调用f()时:
static int i=15 只在第一次进入函数时执行初始化
i++ 使i的值变为16
输出"i=16"
- 第二次调用f()时:
由于i是静态变量,保持了上次的值16
i++ 使i的值变为17
输出"i=17"
所以最终输出为:
i=16
i=17
因此C选项是正确答案。
分析其他选项:
A选项(i=16 i=15)错误:第二次调用时i不会重新初始化为15
B选项(i=15 i=17)错误:第一次输出就是16而不是15
D选项(i=15 i=16)错误:错误理解了static变量的特性
E选项(i=15 i=18)错误:完全不符合程序执行逻辑
这个例子很好地展示了static局部变量的两个重要特性:
只初始化一次
函数调用结束后保持值不变
6.程序段 () 的功能是将变量 u 、 s 中的最大值赋给变量 t.
Aif (u > s) t=u; t=s; Bt=u; if (t > s) t=s; Cif (u > s) t=s; else t=u; Dt=s; if (u > t) t=u;
正确答案：D
官方解析：这道题目考察程序逻辑的实现方式。D选项"t=s; if (u > t) t=u;"是正确的,因为它能准确实现将变量u和s中的最大值赋给变量t的功能。
具体分析D选项的执行过程:
先将s的值赋给t
然后判断u是否大于t(即s),如果u更大则将u赋给t
这样就能保证t最终存储的是u和s中的较大值
分析其他错误选项:
A. "if (u > s) t=u; t=s;" 错误原因:无论if条件是否成立,最后都会执行t=s,导致t始终等于s的值
B. "t=u; if (t > s) t=s;" 错误原因:逻辑完全相反,这段代码会将较小值赋给t,而不是较大值
C. "if (u > s) t=s; else t=u;" 错误原因:条件成立时应该取u而不是s,条件不成立时应该取s而不是u,整个逻辑完全相反
D选项的实现最简洁且逻辑正确,能够确保将u和s中的最大值正确赋给变量t。
7.将两个字符串连接起来组成一个字符串时，选用（ ）函数。
Astrlen() Bstrcap() Cstrcat() Dstrcmp()
正确答案：C
官方解析：strcat()函数是C语言标准库中专门用于字符串连接的函数,它可以将两个字符串拼接在一起,所以C选项是正确答案。具体来说,strcat()函数会将第二个字符串追加到第一个字符串的末尾,形成一个新的字符串。
分析其他选项:
A. strlen()函数是用来计算字符串长度的,不具备字符串连接功能。它返回字符串中字符的个数(不包括结束符'')。
B. strcap()不是C语言标准库中的函数。可能是把stricmp()或strupr()等函数名记错了。
D. strcmp()函数是用来比较两个字符串是否相等的,它通过比较字符串中对应位置的字符来判断字符串的大小关系,返回值为整数,不具备字符串连接功能。
举例说明strcat()的使用:
char str1[50] = "Hello ";
char str2[] = "World";
strcat(str1, str2);
执行后str1的内容变为"Hello World"
所以在需要连接字符串时,strcat()函数是最合适的选择。
8.有以下程序
|-------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 |#include <stdio.h>voidfun(``intx, ``inty, ``int*c, ``int*d) {``*c = x + y;``*d = x - y;}intmain() {``inta = 4, b = 3, c = 0, d = 0;``fun(a, b, &c, &d);``printf``(``"%d %d"``, c, d);}|程序的输出结果是?
A0 0 B4 3 C3 4 D7 1
正确答案：D
官方解析：主函数中首先初始化整型变量a、b、c、d分别为4、3、0、0。调用函数fun,将实参传递给形参。在fun函数内,﹡c ＝ 7、﹡d ＝ 1。返回主函数,最后输出7和1。因此D选项正确。
9.以下程序输出的结果是（）
|-----------|-------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 |main() {``inta = 5, b = 4, c = 3, d;``d = (a > b > c);``printf``(``"%d\n"``, d);}|A5 B4 C3 D0
正确答案：D
官方解析：这道题考察了C语言中运算符的优先级和运算规则。表达式 d = (a > b > c) 的计算结果为0。
具体分析过程如下：
由于关系运算符 > 是从左向右结合的，所以表达式 (a > b > c) 会先计算 a > b
a > b 的结果是 1（因为5 > 4为真，在C语言中真用1表示）
然后计算 1 > c，即 1 > 3
1 > 3 为假，结果是0
最后d被赋值为0
所以D选项是正确答案。
其他选项错误原因：
A(5)错误：这是变量a的值，而不是最终表达式的计算结果
B(4)错误：这是变量b的值，不是最终结果
C(3)错误：这是变量c的值，不是最终结果
这道题的关键在于理解关系运算符的运算规则：
关系运算的结果只有0(假)和1(真)两种
多个关系运算符连续使用时是从左到右计算的
第一次比较的结果(0或1)会参与下一次比较
10.有以下程序
|-------------|---------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |int main() {``char a = ``'a',b;``printf(``"%c,"``, ++a);``printf(``"%c\n"``, b = a++);``return 0;}|程序运行后的输出结果是（）
Ab,b Bb,c Ca,b Da,c
正确答案：A
官方解析：让我们逐步分析这段代码的执行过程:
- 初始状态:
char a = 'a' // a的ASCII码是97
- 第一个printf:
++a 是前置自增,先将a的值加1变成'b',然后输出,所以输出"b"
- 第二个printf:
b = a++ 是一个赋值表达式,会先将a的值赋给b(此时a是'b'),然后a再自增
所以b得到的是'b',因此输出"b"
所以完整输出为:"b,b",对应选项A
分析其他选项:
B选项(b,c)错误:第二个输出是b而不是c,因为后置自增是在赋值之后才发生的
C选项(a,b)错误:第一个输出就是b而不是a,因为有前置自增运算
D选项(a,c)错误:两个输出都不正确,原因同上
这道题目主要考察了:
字符变量的自增运算
前置(++a)和后置(a++)自增运算符的区别
赋值表达式中的运算顺序
前置自增是先增加再使用,后置自增是先使用再增加,这是解答此类问题的关键。
11.若给定如下定义：
|-----|-------------------------------|
| 1 2 |intarray[8];int*p;|如果令指针p指向array数组，那么，*(p+3)表示的是（）
A元素a[4]对应的数据 B元素a[4]对应的地址
C元素a[3]对应的数据 D元素a[3]对应的地址
正确答案：C
官方解析：本题考查的是指针的基础应用。当指针p指向array数组时，系统默认指向数组的第一个元素的地址，因此p+3对应数据的第四个元素的地址，也就是a[3]的地址，通过对p+3解指针引用，也就是*(p+3)表示的是元素a[3]对应的数据。正确答案是C选项。
12.以下程序的输出结果是：
|-------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |#include <stdio.h>#define M(x, y, z) x *y + zmain() {``inta = 1, b = 2, c = 3;``printf``(``"%d\n"``, M(a + b, b + c, c + a));}|A19 B17 C15 D12
正确答案：D
官方解析：分析：#define的边际效应，直接展开，变成a+b*b+c+c+a，详见找工作笔试面试那些事儿(1)---C,C++基础和编程风格(2)
13.以下说法错误的是：
A指针和引用做为函数参数都可以改变实参
B指针和引用都可以在定义后任意的改变指向
C引用必须在创建的时候初始化，而指针则不需要
D不能空引用，但是可以有空指针
正确答案：B
官方解析：这道题目主要考察了C++中指针和引用的基本特性和区别。B选项错误,因为引用在定义时就必须初始化,一旦初始化后就不能改变其指向。而指针可以随时改变所指向的对象。
分析其他选项:
A正确:指针和引用作为函数参数时都可以改变实参的值。通过指针或引用,函数内部可以直接访问和修改实参。
C正确:引用必须在创建时初始化,这是引用的一个重要特性。而指针可以先声明,后续再赋值。
D正确:引用必须指向一个已经存在的对象,不能是空引用。而指针可以是空指针(nullptr),表示不指向任何对象。
总结:指针和引用的主要区别在于:
引用必须初始化且不能更改指向
引用不能为空
指针可以随时改变指向
指针可以为空
14.在下列选项中，正确的字符常量为（）
A"a" B'name' Ca D'\101'
正确答案：D
你的答案：C
官方解析：字符常量是用单引号括起来的单个字符,包括普通字符和转义字符序列。'101'是一个合法的字符常量,表示八进制ASCII码101所对应的字符,因此D是正确答案。
分析其他选项的错误原因:
A选项 "a" 使用了双引号,这是字符串常量的表示方法,而不是字符常量。字符常量必须使用单引号。
B选项 'name' 在单引号内包含了多个字符,这违反了字符常量只能包含单个字符的规则。
C选项 a 没有使用任何引号,这表示的是标识符或变量名,而不是字符常量。
字符常量的正确表示方法包括:
普通字符,如 'a', 'b', '1' 等
转义字符序列,如 ' ', ' ', '101'(八进制), 'u0041'(Unicode) 等
需要注意的是:
字符常量必须用单引号
只能包含单个字符
可以使用转义序列表示特殊字符
15.从下列选项中选择不会引起二义性的宏定义是（）
A#define POWER(x) x*x
B#define POWER(x) ((x)*(x))
C#define POWER(x) (x*x)
D#define POWER(x) (x)*x
正确答案：B
16.若要求在if后一对圆括号中表示a不等于0的关系，则能正确表示这一关系的表达式为______。
Aa<>0 B!a Ca=0 Da
正确答案：D
官方解析：在C语言中,表示"a不等于0"的关系时,正确的写法是直接使用变量a作为条件表达式。在C语言中,任何非0值都表示真,0表示假。因此当a不等于0时,条件表达式的结果就是真,这正是我们需要的逻辑。
选项D "a" 是正确答案,因为:
当a不等于0时,a的值为非0值,条件为真
当a等于0时,a的值为0,条件为假
这完全符合我们要表达"a不等于0"的逻辑需求
分析其他选项:
A错误:"a<>0"不是C语言的语法,C语言中不等于用"!="表示
B错误:"!a"表示的是a为0时为真,a不为0时为假,与题目要求的逻辑相反
C错误:"a=0"是赋值语句而不是关系运算,且逻辑与题目要求相反
这个考点体现了C语言中的一个重要特性:在条件表达式中,任何非0值都被视为真,0被视为假。理解这一点对于编写C语言程序非常重要。
17.（判断题）对于整数 n，(n & (n-1) ) == 0 的含义是判断 n 是否为偶数。
A正确 B错误
正确答案：B
你的答案：A
官方解析：表达式 n & (n-1) == 0 的含义是判断一个数是否为2的整数次幂(包括0),而不是用来判断偶数。
证明分析:
- 对于2的整数次幂的二进制表示,只有一位是1,其余位都是0
例如:
2⁰ = 1 的二进制是 0001
2¹ = 2 的二进制是 0010
2² = 4 的二进制是 0100
2³ = 8 的二进制是 1000
- 当n是2的整数次幂时,n-1的二进制表示会把n中最高位的1变成0,并把右边所有位都变成1
例如:
8(1000) - 1 = 7(0111)
4(0100) - 1 = 3(0011)
- 因此n & (n-1)的结果一定是0
而对于判断偶数,只需要看最低位是否为0即可,使用 n & 1 == 0 才是判断偶数的正确方式。
例如:
6(0110) & 5(0101) = 4(0100) ≠ 0
这说明该表达式对于一般的偶数并不成立。
所以选项A错误,B正确。这个表达式实际上是一个判断数字是否为2的整数次幂的经典位运算技巧。
18.以下程序输出结果为：
|-------------|----------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |#include<stdio.h>#define add(a,b) a+bintmain() {``printf(``"%d\n"``,``3* add(``4``,``7``));``return0``;}|A33 B19 C25 D49
正确答案：B
官方解析：这道题目涉及宏定义和运算符优先级。在本题中,宏定义 add(a,b) 会被简单地展开替换为 a+b。
当执行 3 * add(4,7) 时:
首先宏展开: 3 * 4+7
由于乘法运算符 * 优先级高于加法运算符 +
所以实际计算顺序是: (3 * 4) + 7
即: 12 + 7 = 19
因此 B 选项 19 是正确答案。
分析其他选项:
A选项 33: 可能是误认为计算顺序是 3 * (4+7)
C选项 25: 计算过程错误
D选项 49: 可能是误认为宏定义会形成独立的运算单元 3 * (4+7)
这个题目的关键点是:
宏定义是简单的文本替换,不会形成独立运算单元
必须注意运算符的优先级
如果想要得到 3*(4+7) 的结果,宏定义应该写成 #define add(a,b) ((a)+(b))
19.当宏定义需要定义多行代码时，会使用下列哪个符号（）
A| B/ C\ D-
正确答案：C
官方解析：在C语言的宏定义中,当需要在一个宏中定义多行代码时,需要使用反斜杠符号"\"来实现换行续写。这个反斜杠必须放在每一行的末尾(最后一行除外),表示下一行仍然是当前宏定义的延续。
选项C的"\"是正确答案,因为:
它是C语言规定的宏定义换行续写符号
使用"\"可以让宏定义的代码更加清晰易读
编译器会将带有"\"的多行宏定义视为一个完整的宏
分析其他选项:
A. "|"是位运算符,不能用作宏定义换行
B. "/"是除法运算符,不能用作宏定义换行
D. "-"是减法运算符,不能用作宏定义换行
示例用法:
#define MAX(a,b)
((a) > (b) ?
(a) : (b))
需要注意的是:
反斜杠后面不能有任何字符(包括空格)
反斜杠必须是每行的最后一个字符
最后一行不需要加反斜杠
20.有如下类定义：
|-----------------|-------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 |classA {``public``:``intfun1();``virtualvoidfun2();``private``:``int_a;};|在32位机器上，请问sizeof(A)的值为：
A12 B8 C4 D1
正确答案：B
官方解析：在32位机器上，sizeof(A)为8字节，这是由类A的内存布局决定的：
- 类A包含以下内存开销：
一个int类型成员变量_a，占用4字节
由于存在virtual函数fun2()，需要一个虚函数表指针(vptr)，在32位机器上占用4字节
普通成员函数fun1()不占用对象的内存空间
- 各选项分析：
A选项(12字节)错误：高估了内存占用，实际只需要8字节
B选项(8字节)正确：符合实际内存布局(4字节vptr + 4字节int)
C选项(4字节)错误：仅考虑了int成员变量，忽略了虚函数表指针
D选项(1字节)错误：远小于实际所需内存空间
补充说明：
即使类中包含多个虚函数，也只需要一个虚函数表指针
成员函数(包括虚函数)的代码存储在代码段，不占用对象空间
编译器会进行字节对齐，但本例中不需要额外的填充字节
因此在32位系统中，该类对象的大小就是8字节。
21.若有语句：int s[3][3],(*p)[3];p=s;则对s数组元素的引用形式正确的是__________
Ap+1 B*(p+1) Cp[1][2] D*(p+1)+2
正确答案：C
你的答案：B
官方解析：这道题目考察了C语言中指针数组和二维数组的基本概念和使用。
在题目中，定义了一个3×3的二维数组s和一个指向包含3个元素的一维数组的指针p，并将p指向s。此时p实际上就成为了指向二维数组s的指针。
C选项 p[1][2] 是正确的，原因如下：
p=s 后，p指向二维数组s的首地址
p[1][2] 等价于 *(*(p+1)+2)，表示访问第2行第3列的元素
这种访问方式与直接使用s[1][2]是等价的，都能正确访问到数组元素
分析其他选项：
A错误：p+1 只是一个地址值，并不能表示对数组元素的引用
B错误：*(p+1) 得到的是第二行的首地址，仍然不是具体的数组元素
D错误：*(p+1)+2 得到的是第二行第三个元素的地址，而不是元素值
这里需要注意的是，当p指向二维数组时，可以用p[i][j]的形式来访问数组元素，这种形式更直观且等价于使用指针的解引用操作*(*(p+i)+j)。
22.下面程序段的运行结果是（）
|-------|-----------------------------------------------------------------------------------------------------|
| 1 2 3 |chars[]=``"abcdefgh"``,*p =s;p += 3;printf(``"%d\n"``, strlen(strcpy(p,``"ABCD"``)));|A8 B12 C4 D7
正确答案：C
官方解析：
【解释】strcpy(p,"ABCD")的功能是将字符串"ABCD"复制到指针变量p所指向的内存
单元中，其返回值是指针p所指内存单元的地址，然后计算p所指字符串的长度，显然是
4。所以正确答案是C。
|-------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |#include <iostream>#include <map>usingnamespacestd;intmain() {``intn;``scanf``(``"%d"``, &n);``map<``int``, ``int``> xs;``map<``int``, ``int``> ys;``map<pair<``int``, ``int``>, ``int``> zs;``longlongans = 0;``for(``inti = 0; i < n; i++) {``intx, y;``scanf``(``"%d %d"``, &x, &y);``ans += (xs[x]++);``ans += (ys[y]++);``ans -= (zs[make_pair(x, y)]++);``}``cout << ans << endl;``return0;}|输入：
6
0 0
0 1
0 2
-1 1
0 1
1 1
则上述程序输出为（）
A9 B10 C11 D12
正确答案：C
官方解析：这道题目考察了对C++中map容器的理解以及点的重复计数问题。
让我们逐步分析程序的执行过程：
- 程序维护了三个map:
xs统计每个x坐标出现的次数
ys统计每个y坐标出现的次数
zs统计每个具体坐标点(x,y)出现的次数
- 对于每个输入的点(x,y):
ans += xs[x]++ 表示与已有的同x坐标的点能构成的对数
ans += ys[y]++ 表示与已有的同y坐标的点能构成的对数
ans -= zs[make_pair(x,y)]++ 表示减去重复计算的完全相同的点的对数
- 对于输入数据:
(0,0),(0,1),(0,2),(-1,1),(0,1),(1,1)
- 计算过程:
(0,0): ans=0
(0,1): ans=1(同x)
(0,2): ans=3(同x:2次)
(-1,1): ans=5(同y:2次)
(0,1): ans=8(同x:3次 + 同y:3次 - 重复点:1次)
(1,1): ans=11(同x:0次 + 同y:4次)
因此最终结果是11，C选项正确。
其他选项分析：
A(9)、B(10)和D(12)都没有正确统计点的重复情况。这个问题的关键在于理解：
当出现相同x或y坐标时，要加上已经出现的次数
当出现完全相同的点时，需要减去重复计算的次数
最后一个点(1,1)虽然x坐标是新的，但y坐标已经出现过4次，所以要加4
24.下面函数输出结果是（）
|-----------|--------------------------------------------------------------------------------------------|
| 1 2 3 4 5 |intmain() {``intk = 12345;``printf``(``"%2d\n"``, k);``return0;}|A12 B45 C12345 D无法通过编译
正确答案：C
官方解析：这道题考察了C语言printf函数格式化输出的基础知识。
%2d是printf的格式控制符,其中2表示最小输出宽度为2。当要输出的整数k=12345的位数超过指定的最小宽度2时,会按照实际的位数完整输出,所以会输出12345。
分析各选项:
A错误:输出12是不正确的,因为整数12345的实际位数大于指定的最小宽度2,不会被截断
B错误:输出45是不正确的,printf不会因为宽度设置而截取数字的后两位
C正确:当整数的实际位数大于指定的最小宽度时,会按照实际位数完整输出原始数值12345
D错误:这段代码可以正常编译运行,语法没有问题
补充说明:如果想要截断或者限制输出位数,需要使用其他格式控制符如%.2d。而%2d中的2仅表示最小输出宽度,当实际数字的位数超过这个宽度时,会保持原样输出。
25.关于下面代码的说法正确的是（）
|-------|-----------------------------------------------------|
| 1 2 3 |extern"C"{``voidfoo(``int``) { }}|A"C" 代表c语言
B这段代码应于在c++语言代码中
C这段代码告诉c++调用者这是一段C代码
D用nm查看，foo实际被命名为类似风格 `__Z4fooi`
正确答案：B
你的答案：A
官方解析：extern "C" 是一个 C++ 语言特性,用于实现 C++ 代码与 C 代码的互操作性,这段代码必须在 C++ 代码中使用,因此 B 选项正确。
分析其他选项:
A 错误:extern "C" 不是简单代表 C 语言,而是一个 C++ 链接规范(linkage specification),用来告诉 C++ 编译器按照 C 语言的方式来处理函数的命名和链接。
C 错误:这段代码不是告诉 C++ 调用者这是一段 C 代码,而是告诉 C++ 编译器使用 C 语言的命名约定来编译这个函数,使其可以被 C 代码调用。
D 错误:使用 extern "C" 声明的函数在编译后的符号表中不会使用 C++ 的名称修饰(name mangling)规则,即不会产生类似 __Z4fooi 这样的符号名。相反,它会保持简单的符号名 foo。
这种语法的主要作用是解决 C++ 与 C 的接口问题。因为 C++ 支持函数重载,所以编译器会对函数名进行修饰以区分不同的重载版本,而 C 语言不支持重载,通过 extern "C" 可以让 C++ 编译器生成 C 风格的符号名,从而实现与 C 代码的互操作。
|-------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |classt_classA {public``:``t_classA() {};``~t_classA() {};};classt_classB {public``:``t_classB() {};``virtual~t_classB() {};};classt_classC : ``publict_classA, ``publict_classB {public``:``t_classC() {};``virtual~t_classC() {};};intnLenA = ``sizeof``(t_classA);t_classA oA;intnLenAObject = ``sizeof``(oA);intnLenB = ``sizeof``(t_classB);t_classB oB;intnLenBObject = ``sizeof``(oB);intnLenC = ``sizeof``(t_classC);t_classC oC;intnLenCObject = ``sizeof``(oC);|请问：nLenA、nLenAObject、nLenB、nLenBObject、nLenC、nLenCObject的值（32位机器）分别为（）
A1，1，4，4，8，8
B0，0，4，4，4，4
C0，0，4，4，8，8
D1，1，4，4，4，4
正确答案：D
你的答案：C
官方解析：这道题目主要考察C++中类的内存布局和虚函数对类大小的影响。让我们逐个分析各个类的大小:
t_classA是一个普通类,只有默认的构造和析构函数,没有任何成员变量和虚函数,在32位系统下占用1字节(为了保证对象的唯一性)。因此nLenA和nLenAObject都是1。
t_classB有一个虚析构函数,会生成虚函数表指针(vptr),在32位系统下vptr占4字节。所以nLenB和nLenBObject都是4。
t_classC继承自t_classA和t_classB,由于t_classA是普通类占1字节,t_classB有虚函数占4字节,但由于字节对齐,t_classC的大小为4字节。因此nLenC和nLenCObject都是4。
所以D选项(1,1,4,4,4,4)是正确答案。
分析其他选项:
A(1,1,4,4,8,8)错误:认为t_classC的大小是父类大小之和,没考虑内存对齐。
B(0,0,4,4,4,4)错误:空类大小至少是1字节。
C(0,0,4,4,8,8)错误:既错误计算了空类大小,又错误计算了继承类的大小。
这道题的关键是要理解:
空类占1字节
有虚函数的类需要存储vptr(4字节)
继承时要考虑内存对齐
27.运行以下C语言代码，输出的结果是（）
cpp#include <stdio.h> #include <string.h> #include <stdlib.h> int main(int argc, const char *argv[]) { char *str[3]={"stra","strb","strc"}; char *p=str[0]; int i=0; while(i<3){ printf("%s",p++); i++; } return 0; }Astra tra ra
Bstra strb strc
Cs t r
Ds s s
正确答案：A
官方解析：
char *str[3] = {"stra","strb","strc"};是一个指针一维数组，p指向首地址，那么p++肯定是移动到下一地址，只要区别了这是个一维数组，而不是二维数组就好分别出答案了。
解析：
定义字符指针数组 str：char *str[3]={"stra","strb","strc"}; 定义了一个包含 3 个元素的字符指针数组，每个元素分别指向字符串 "stra"、"strb" 和 "strc" 的首地址。
初始化字符指针 p：char *p=str[0]; 让指针 p 指向 str 数组的第一个元素，也就是字符串 "stra" 的首地址。
while 循环：
循环条件为 i < 3，循环体执行 3 次。
在每次循环中，printf("%s",p++); 会先输出 p 所指向的字符串，然后 p 指针向后移动一个字符的位置。
具体执行过程
第一次循环（i = 0）：
p 指向 "stra" 的首字符 's'，printf("%s",p++); 输出从 's' 开始的字符串 "stra"，然后 p 指向 't'。
第二次循环（i = 1）：
p 指向 't'，printf("%s",p++); 输出从 't' 开始的字符串 "tra"，然后 p 指向 'r'。
第三次循环（i = 2）：
p 指向 'r'，printf("%s",p++); 输出从 'r' 开始的字符串 "ra"，然后 p 指向 'a'。
28.在 32 位 cpu 上选择缺省对齐的情况下，有如下结构体定义：
|---------------|-------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 |structA {``unsigned a : 19;``unsigned b : 11;``unsigned c : 4;``unsigned d : 29;``charindex;};|则 sizeof(struct A) 的值为（）
A9 B12 C16 D20
正确答案：C
你的答案：D
官方解析：这道题目考察了结构体内存对齐的相关知识。在32位CPU上采用默认对齐方式时，结构体大小的计算需要考虑位域(bit-field)和字节对齐。
让我们详细分析结构体A的内存布局：
- 前三个位域成员 a(19位)、b(11位)、c(4位) 总共占用34位，由于unsigned int是32位，所以会占用两个unsigned int：
第一个unsigned int存放a和b的一部分
第二个unsigned int存放b剩余部分和c
d成员需要29位，会单独占用一个unsigned int（32位）
index是char类型，占1字节
按照对齐规则：
结构体的起始位置必须是其最大基本类型成员的整数倍
在32位系统中，unsigned int的对齐要求是4字节
结构体的总大小必须是最大对齐数的整数倍
所以实际内存布局为：
前两个unsigned int占8字节
第三个unsigned int(存d)占4字节
char类型的index占1字节
为了满足4字节对齐，需要补充3字节的填充
因此总大小为：8 + 4 + 1 + 3 = 16字节
所以C选项(16)是正确答案。
其他选项分析：
A(9)错误：没有考虑对齐要求
B(12)错误：计算结果不完整
D(20)错误：超出了实际所需空间
29.C++中struct 和 class 的区别?
Astruct 的成员默认是公有的
Bstruct 的成员默认是私有的
Cclass的成员默认是私有的
Dclass的成员默认是公有的
正确答案：AC
官方解析：C++中struct和class是两种用于定义用户自定义数据类型的关键字,它们的主要区别在于成员的默认访问权限不同。
A选项正确:在struct中,如果不显式声明访问权限,其成员(包括变量和函数)默认是public(公有的)。这意味着这些成员可以被外部直接访问。
C选项正确:在class中,如果不显式声明访问权限,其成员默认是private(私有的)。这体现了类的封装特性,private成员只能在类的内部访问。
分析错误选项:
B选项错误:struct的成员默认是public而不是private,这是struct区别于class的关键特征。
D选项错误:class的成员默认是private而不是public,这是class实现数据封装的基本机制。
除了默认访问权限的区别外,struct和class的其他特性是完全相同的,都支持继承、多态等面向对象特性。选择使用struct还是class主要取决于设计意图,通常struct用于表示简单的数据结构,而class用于实现更复杂的对象。
30.下列函数定义中，有语法错误的是（）
Avoid fun(int x, int y){x = *y;}
Bint * fun(int *x, int y){return x += y;}
Cvoid fun(int *x, int y){*x += y;}
Dvoid fun(int x, int y){*x = *y;}
正确答案：AD
官方解析：这道题考察了C语言中指针相关的函数语法。D选项是错误的，因为在函数参数声明中x和y都是普通的int类型变量，不是指针类型，因此不能使用*运算符进行解引用操作。
分析各个选项：
A选项正确：
函数参数为int类型，但表达式x = *y有语法错误，因为y不是指针类型，不能进行解引用。
B选项正确：
函数返回int指针类型，参数x是int指针类型，y是int类型。表达式x += y对指针进行算术运算是合法的。
C选项正确：
函数参数x是int指针类型，y是int类型。表达式*x += y通过解引用修改x指向的值是合法的。
D选项错误：
函数参数x和y都是普通int类型，不是指针。表达式*x = *y试图对非指针类型变量进行解引用操作，这在C语言中是不允许的，会导致编译错误。
总结：D选项的错误在于对非指针类型变量使用了解引用操作符*，这是C语言语法所不允许的。如果要实现这样的功能，应该将参数声明为指针类型。
试卷02
1.main 函数执行以前，还会执行什么代码？
A全局对象的构造函数
B全局对象的析构函数
C局部对象的构造函数
D局部对象的析构函数
正确答案：A
你的答案：B
官方解析：在C++程序中，main函数执行之前会先执行全局对象(包括全局变量、静态成员变量等)的构造函数。这是因为全局对象的生命周期贯穿整个程序，它们需要在程序启动时就完成初始化。
分析其他选项的错误原因：
B错误：全局对象的析构函数是在main函数执行结束后，程序退出时才会执行，用于清理全局对象占用的资源。
C错误：局部对象的构造函数是在进入该对象所在的作用域时才会执行，而不是在main函数之前。
D错误：局部对象的析构函数是在离开该对象作用域时才会执行，同样不是在main函数之前。
补充说明：C++程序的启动顺序是：
首先执行全局对象的构造函数
然后执行main函数
main函数结束后执行全局对象的析构函数
局部对象的构造和析构都发生在其作用域内
因此A选项"全局对象的构造函数"是唯一在main函数执行之前就会执行的代码。
2.C 语言规定，在一个源程序中，main 函数的位置必须在最开始。请问这句话的说法是正确的吗？
A正确 B错误
正确答案：B
官方解析：C语言中main函数的位置是灵活的,并不要求必须在程序最开始。main函数可以放在源代码的任何位置,只要确保其他函数在被main函数调用前已经声明或定义即可。
具体分析如下:
C语言程序的执行总是从main函数开始,但这与main函数在源代码中的位置无关。
在实际编程中,常见的做法包括:
将main函数放在源文件开头
将main函数放在源文件末尾
将main函数放在其他函数之间
这些做法都是合法的。
- 如果main函数不在开头,只需要注意:
如果main函数要调用其他函数,这些函数需要在main函数之前声明
可以通过函数原型声明来解决函数定义在main函数之后的情况
- 选项A错误,因为它错误地认为main函数必须位于程序最开始,这种说法过于绝对且不符合C语言规范。
所以本题选B是正确的,因为它否定了"main函数必须在最开始"这一错误说法。
3.下面四个选项中，均是不合法的用户标识符的选项是（）
AA P_0 do Bfloat la0 _A Cb-a sizeof int Db_a temp _123
正确答案：C
官方解析：在C语言中,标识符的命名必须遵循特定规则。C选项中的所有标识符都不合法,因为:
"b-a"含有非法字符"-"
"sizeof"是C语言关键字,不能用作标识符
"int"也是C语言关键字,不能用作标识符
分析其他选项:
A选项中:
"A"是合法标识符
"P_0"是合法标识符(字母、数字和下划线的组合)
"do"虽然是关键字,但该选项还包含其他合法标识符
B选项中:
"float"虽然是关键字,但该选项还包含其他合法标识符
"la0"是合法标识符
"_A"是合法标识符(可以下划线开头)
D选项中:
"b_a"是合法标识符
"temp"是合法标识符
"_123"是合法标识符(可以下划线开头)
C语言标识符命名规则:
只能由字母、数字和下划线组成
第一个字符必须是字母或下划线
不能是关键字
区分大小写
因此C是唯一所有标识符都不合法的选项。
4.假设变量 s、a、b、c 均已定义为整型变量，且 a、c 均已赋值（c 大于 0），则与以下程序段
|-----|---------------------------------------------------|
| 1 2 |s = a;for(b = 1; b <= c; b++) s = s + 1;|功能等价的赋值语句是（）
As=a+b; Bs=a+c; Cs=s+c; Ds=b+c;
正确答案：B
官方解析：这道题目考察了简单循环语句的等价替换。
让我们分析原始代码:
s = a;
for (b = 1; b <= c; b++) s = s + 1;
这段代码的执行过程是:
先将a的值赋给s
从1到c循环c次,每次将s加1
最终s的值等于初始值a加上循环次数c
因此,这段代码等价于 s = a + c,所以B选项正确。
分析其他选项:
A. s = a + b 错误: b是循环变量,最终值为c+1,不是我们需要的累加次数
B. s = a + c 正确: 直接将初始值a加上循环次数c,得到相同结果
C. s = s + c 错误: s未初始化就直接使用,且没有包含a的值
D. s = b + c 错误: 完全没有用到初始值a,且b是循环变量,取值不正确
这是一个很好的例子,展示了如何将循环累加操作转换为等价的直接计算。当循环体内是简单的累加操作时,我们往往可以用数学方法直接计算出最终结果。
5.假设在上下文和头文件正常的情况以下，下面一段代码的输出结果是
|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 |voidf(``char*c, ``chard) {``*c = *c + 1;``d = d + 1;``cout << *c << d;}intmain() {``chara = ``'A'``, b = ``'a'``;``f(&b, a);``cout << a << b << endl;}|ABaBa BaBaB CAbAb DbBAb
正确答案：D
官方解析：这道题目考察了函数参数传递和指针的概念。让我们逐步分析代码的执行过程：
main函数中定义了两个char类型变量：a='A'，b='a'
调用f(&b,a)函数时：
第一个参数&b是b的地址，传给指针参数c
第二个参数a是值传递，传给参数d
- 在f函数中：
*c = *c + 1 将b的值增加1，'a'变成'b'
d = d + 1 只改变局部变量d的值，不影响main函数中的a
cout << *c << d 输出"b" "B"(因为'A'+1='B')
- 回到main函数：
cout输出a和b的值
a仍然是'A'(未被改变)
b已经变成'b'(通过指针被修改)
所以最终输出"bBAb"
因此D选项"bBAb"是正确答案。
分析其他选项：
A选项"BaBa"错误：没有考虑到指针修改对原变量的影响
B选项"aBaB"错误：完全颠倒了变量的修改顺序
C选项"AbAb"错误：误认为值传递会影响原变量
这道题的关键是理解：指针参数可以修改原变量的值，而值传递的参数修改不会影响原变量。
6.下面哪个语句无法通过编译？
Aif (x>y);
Bif (x=y) && (x!=0) x+= y;
Cif (x!=y) scanf("%d",&x); else scanf("%d",&y);
Dif (x<y) {x++; y++;}
正确答案：B
官方解析：这道题主要考察C语言中if语句的语法规则。B选项无法通过编译是因为语法错误,存在以下问题:
if (x=y) && (x!=0) 这个表达式中的&&运算符前后缺少完整的条件判断结构
赋值表达式x=y需要用括号包裹才能作为条件判断
正确的写法应该是: if ((x=y) && (x!=0))
分析其他选项:
A选项 if (x>y);
这是合法的语句,虽然if后面是空语句(只有一个分号),但语法正确
这种写法可能是一个逻辑错误,但在语法上是允许的
C选项 if (x!=y) scanf("%d",&x); else scanf("%d",&y);
这是完全正确的if-else语句
条件判断和执行语句的语法都符合规范
D选项 if (x- 这是标准的if语句写法
- 使用了代码块{}包含多条语句,语法完全正确
因此,只有B选项存在语法错误,无法通过编译。
|-----------|------------------------------------------------------------------------------------|
| 1 2 3 4 5 |intfun(``inta){``a = (``1<< ``5``) - ``1``;``returna;}|fun(21)结果是（）
A10 B8 C5 D31
正确答案：D
官方解析：这道题目考察了位运算和左移运算符的理解。
函数中的关键操作是 a = (1 << 5) - 1，让我们逐步分析：
- 1 << 5 表示将二进制数1左移5位
1的二进制表示是: 00000001
左移5位后变成: 00100000
这个数的十进制值是32
- (1 << 5) - 1 就是32 - 1 = 31
- 二进制表示为: 00011111
- 虽然函数参数传入了21，但在函数内部直接将a赋值为31，所以参数值在这里并不影响最终结果。
因此，答案选D：31是正确的。
分析其他选项：
A选项(10)：错误，没有任何运算步骤会得到10
B选项(8)：错误，可能是混淆了左移3位的结果
C选项(5)：错误，可能是简单记住了左移的位数，但没有进行完整计算
这个题目的关键是要理解左移运算符(<<)的作用：每左移一位，相当于将数字乘以2。所以左移5位相当于乘以2的5次方(32)，然后再减1得到最终结果31。
8.下面代码段的输出为（）
|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 |intmain () {``floatx=2.0,y；``if``(x<0.0) y=0.0；``elseif(x<10.0) y=1.0/x；``elsey=1.0；``printf``(``"%f\n"``,y)；}|A0.000000 B0.250000 C0.500000 D1.000000
正确答案：C
你的答案：A
官方解析：
【解释】因x的值是2.0，所以x<0.0为假，则执行if(x<0.0)后面的else语句，继续
判断x<10.0，因该条件为真，所以执行y=1.0/x，则y的值为0.5，故正确答案为C。
9.c++当中，char 类型的长度为 ________ 个字节
A1 B2 C3 D4
正确答案：A
官方解析：在C++中,char类型的长度就是1个字节,这是C++语言规范明确规定的。char类型主要用于存储单个字符或者小整数值。
让我们分析一下其他选项为什么不正确:
B选项(2个字节)错误:
这可能与wchar_t类型混淆了。wchar_t是宽字符类型,通常占用2个或4个字节,但char就是标准的1字节。
C选项(3个字节)错误:
在计算机体系结构中没有3字节的基本数据类型,这个选项明显不合理。
D选项(4个字节)错误:
4字节是int类型的典型大小,与char类型的1字节大小不符。
补充说明:
1字节=8位(bits),对于char类型来说:
有符号char的取值范围是-128到127
无符号char的取值范围是0到255
这正好对应一个字节(8位)所能表示的数值范围。
10.下面的代码段
|-------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 |intmain() {``inta = 7, b = 8, *p, *q, *r;``p = &a;``q = &b;``r = p;``p = q;``q = r;``printf``(``"%d,%d,%d,%d\n"``, *p, *q, a, b);}|程序运行后的输出结果是( )
A8,7,8,7
B7,8,7,8
C8,7,7,8
D7,8,8,7
正确答案：C
你的答案：B
官方解析：这道题目主要考察C语言中指针变量的交换操作以及对变量值的影响。让我们逐步分析程序的执行过程：
- 初始状态:
变量 a=7, b=8
p指向a的地址
q指向b的地址
- 指针交换过程:
r=p: r指向a的地址
p=q: p指向b的地址
q=r: q指向a的地址
- 最终状态:
p指向b，所以*p=8
q指向a，所以*q=7
a的值保持不变，仍为7
b的值保持不变，仍为8
因此printf("%d,%d,%d,%d ",*p,*q,a,b)的输出结果为: 8,7,7,8
其他选项分析：
A选项(8,7,8,7)错误：混淆了变量a,b的值，它们的值并未改变
B选项(7,8,7,8)错误：搞错了指针交换后*p和*q的值
D选项(7,8,8,7)错误：没有正确理解指针交换的结果
这个程序只是交换了指针的指向，并没有改变原始变量a和b的值。这是指针操作的一个重要特点。
11.上下文及头文件均正常的情况下，以下程序的输出结果是________。
|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 |voidfut(``int``**s,``intp[2][3]) {``**s=p[1][1];}voidmain( ) {``inta[2][3]={1,3,5,7,9,11},*p;``p=(``int``*)``malloc``(``sizeof``(``int``));``fut(&p,a);``cout<< *p;}|A7 B9 C1 D11
正确答案：B
官方解析：这道题目考察了指针和二维数组的相关知识点。让我们一步步分析代码的执行过程：
- 首先在main函数中定义了一个2×3的二维数组a并初始化:
a[0][0]=1, a[0][1]=3, a[0][2]=5
a[1][0]=7, a[1][1]=9, a[1][2]=11
定义了一个指针p并通过malloc分配了一个整型空间。
调用fut函数时:
第一个参数&p是指针p的地址，类型是int**
第二个参数a是二维数组的首地址
- 在fut函数中:
**s表示对指针p所指向的内存空间进行赋值
p[1][1]就是数组a中第二行第二列的元素，即9
所以**s=p[1][1]就是将9赋值给指针p指向的空间
- 最后输出*p，即输出p指向的内存空间的值，结果为9
因此B选项9是正确答案。
分析其他选项：
A选项7错误：这是a[1][0]的值，不是p[1][1]
C选项1错误：这是a[0][0]的值
D选项11错误：这是a[1][2]的值
这道题目的关键是要理解二维数组的访问方式以及多重指针的解引用操作。通过**s可以修改指针p指向的内存空间的值。
12.下列函数的功能是（ ）
|-----|------------------------------------------------------------------------------------|
| 1 2 |f(``char* x, ``char* y){ ``do``{x++,y++;} ``while``((*x==*y)!='\0'); }|A将y所指字符串赋给x所指空间
B使指针x指向y所指字符串
C将x所指字符串和y所指字符串进行比较
D检查x和y所指字符串中是否有'\0'
正确答案：C
官方解析：这道题目考察了C语言中字符串比较的函数实现。
函数中使用do-while循环,每次将x和y指针同时向后移动(x++,y++),直到遇到两个字符不相等或遇到字符串结束符''为止。这个过程实际上就是在逐个比较两个字符串对应位置的字符,因此该函数的功能是比较两个字符串。
具体分析选项:
C正确:该函数通过循环比较两个指针指向的字符串内容是否相同,实现了字符串比较的功能。
A错误:该函数没有进行赋值操作,只是在比较字符,并不会将y指向的字符串复制到x指向的空间。
B错误:函数中只是移动了指针位置(x++,y++),并没有改变x指针本身指向的地址,不会使x指向y所指的字符串。
D错误:函数的终止条件(*x==*y)!=''实际上是在比较字符是否相等,而不是专门用来检查是否有''。虽然''会影响比较结果,但这不是函数的主要功能。
需要注意的是,这个函数实现可能存在一些边界情况的问题,在实际编程中使用标准库函数strcmp()会更安全可靠。
13.外部变量可以供其所在的程序文件中的任何函数使用（）
A正确 B错误
正确答案：B
你的答案：A
官方解析：外部变量的作用域规则是:它只对定义它的源文件内从其定义点开始到源文件结束之间的程序代码有效。即外部变量仅对定义它之后的函数可见,而不是文件中所有函数都可以使用。
选项A错误,"文件中的任何函数"这个说法过于绝对。因为:
在外部变量定义之前的函数无法使用该变量
如果外部变量声明在某个函数内部,那么它的作用域就被限制在该函数内部
static声明的外部变量作用域仅限于当前源文件
选项B正确,因为外部变量的作用域受到定义位置的限制,不是对整个文件中的所有函数都可见。需要遵循以下规则:
只对定义点之后的代码有效
作用域范围取决于变量的声明位置
受static等关键字修饰符的影响
所以说外部变量并不是可以供其所在程序文件中的"任何"函数使用,其可见性和作用域是有限制的。
14.在 C 语言中有如下声明：char color = 'B'; 请问'B'和color分别占（）内存。
A1字节、1字节 B1字节、2字节 C2字节、1字节 D2字节、2字节
正确答案：A
官方解析：
字符变量占用一个字节，所以color占1字节。
字符常量存储为int类型（不是char类型），也就是说'B'通常占用2或4字节，但实际上只使用int的1字节存储'B'的编码。
所以正确答案为A。
若k为整形,下述while循环的次数为:()
|-------------|----------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |intk=``1000``;while(k > ``1``){``printf(``"%d\n"``, k);``k = k / ``2``;}|A1000 B10 C11 D9
正确答案：D
官方解析：这道题目考察循环次数的计算。要得到正确结果,我们需要追踪k的值的变化过程。
循环过程分析:
起始值 k = 1000
第1次: k = 1000/2 = 500
第2次: k = 500/2 = 250
第3次: k = 250/2 = 125
第4次: k = 125/2 = 62
第5次: k = 62/2 = 31
第6次: k = 31/2 = 15
第7次: k = 15/2 = 7
第8次: k = 7/2 = 3
第9次: k = 3/2 = 1
当k = 1时,不满足循环条件k > 1,循环结束。所以总共循环了9次,D选项正确。
分析其他选项:
A选项1000错误:这是k的初始值,而不是循环次数
B选项10错误:实际计算后可知循环次数是9次而不是10次
C选项11错误:过大估计了循环次数
注意:由于k是整型,除法运算会自动向下取整。这是得到正确结果的关键点。
16.指针函数是指函数的返回值为指针的函数.说法的是否正确？
A正确 B错误
正确答案：A
官方解析：这道题目考察的是指针函数的基本概念。A选项正确地表述了指针函数的定义。
指针函数就是返回值为指针类型的函数。其一般形式为：
数据类型 *函数名(参数列表)
例如：
int *getNumber() // 返回一个整型指针
char *getString() // 返回一个字符指针
需要注意的是,指针函数和函数指针是两个不同的概念:
指针函数是指返回值为指针的函数
函数指针是指向函数的指针
这就好比"指针变量"和"变量指针"的区别:
指针变量是一个变量,用来存储地址
变量指针是指向变量的指针
因此原题中的说法完全正确。指针函数的定义就是"返回值为指针的函数"。这个定义准确地描述了指针函数的本质特征。B选项错误,因为它否定了一个正确的定义。
17.对于下面的语句
|-----|------------------------------------|
| 1 2 |intc[4][5], (*p)[5];p = c;|能正确引用c数组元素的是（）
Ap + 1 B*(p + 3) C*(p + 1) + 3 D*(p[0] + 2)
正确答案：D
官方解析：这道题目考察了C语言中指针数组的基本概念和运算。首先需要理解题目中的声明:p是一个指向包含5个整数的数组的指针，而c是一个4×5的二维数组。执行p = c后，p指向c的第一行。
让我们逐个分析各选项：
D选项正确：*(p[0] + 2)等价于c[0][2]，其中p[0]指向第一行数组的首地址，+2表示偏移两个元素，最后解引用可以正确访问到第一行第三个元素。
分析错误选项：
A. p + 1：这是一个指针运算，结果是指向第二行的指针，但未进行解引用，不能直接访问元素值
B. *(p + 3)：这个表达式得到的是第四行的数组，而不是具体元素
C. *(p + 1) + 3：这个表达式得到的是第二行起始地址加3的位置，但未进行最终解引用，不能访问元素值
本题的关键是理解：
p是行指针，每次+1移动一行
正确访问数组元素需要完整的解引用操作
p[i]等价于*(p+i)，表示获取第i行的首地址
因此只有D选项正确地完成了数组元素的访问。
18.求输出结果
|-------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |#include<stdio.h>inta[2][2][3] = {``{``{1, 2, 3}, {4, 5, 6}}, {``{7, 8, 9}, {10, 11, 12}}};int*ptr = (``int*)(&a + 1);intmain(){printf``(``"%d %d"``, *(``int``*)(a + 1), *(ptr - 1));}|A7 12 B1 6 C1 3 D7 9
正确答案：A
官方解析：这道题目考察了C语言中数组和指针的概念,以及多维数组在内存中的存储方式。
让我们分析表达式计算过程:
- *(int*)(a+1) 的计算:
a是一个三维数组,a+1表示移动到数组的第二个元素,即第二个二维数组的起始位置
因此*(int*)(a+1)得到的是第二个二维数组的第一个元素,即7
- *(ptr-1) 的计算:
&a+1 表示跳过整个三维数组,指向数组末尾
ptr-1 表示向前移动一个int大小,即指向数组最后一个元素
因此*(ptr-1)得到最后一个元素的值,即12
所以最终输出结果是 7 12,A选项正确。
分析其他选项:
B(1 6):错误。1是数组第一个元素,6是第一个二维数组的最后一个元素,与实际指针运算结果不符
C(1 3):错误。这是完全错误的理解,与指针运算规则不符
D(7 9):错误。7是对的,但9不是最后一个元素,最后一个元素是12
这个题目的关键是理解:
多维数组在内存中是连续存储的
指针运算时要注意步长的计算
&a+1表示跳过整个数组空间
19.对于下面程序
|-------------|--------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |intmain() {``inta=5,b=0,c=0;``if(a=b+c) printf (``"***\n"``);``elseprintf(``"$$$\n"``);``return0;}|说法正确的是（）
A有语法错不能通过编译
B可以通过编译但不能通过连接
C输出***
D输出$$$
正确答案：D
官方解析：这道题目考察的是C语言中赋值运算符和条件判断的概念。
在程序中关键在于if语句的条件判断:if (a=b+c)。这里需要注意以下几点：
表达式中使用的是赋值运算符"="而不是相等比较运算符"=="
b=0，c=0，所以b+c=0
a=b+c实际上是将0赋值给a，而不是进行比较
在C语言中，if条件判断时，0为假，非0为真
因此if (a=b+c)实际上是if (0)，结果为假
所以程序会执行else分支，输出"$$$"。因此D选项是正确答案。
分析其他选项：
A错误：程序在语法上完全正确，可以通过编译
B错误：程序不仅能通过编译，还能正确链接和执行
C错误：由于if条件判断结果为假，不会执行if分支，因此不会输出"***"
这道题目的关键是要理解赋值运算符在条件判断中的行为，以及C语言中0和非0值在条件判断中的含义。这也提醒我们在编程时要注意区分"="和"=="的使用，避免类似的逻辑错误。
20.执行如下代码后。 b 的值是（）
int a = 2, b = 0; do { --b; } while (a --> 0);A-1 B-2 C-3 D死循环
正确答案：C
你的答案：B
官方解析：这道题目考察了do-while循环和自减运算符的执行顺序。让我们逐步分析代码的执行过程：
初始状态: a = 2, b = 0
do-while循环的特点是先执行循环体,再判断条件。循环体中的操作是 --b，while条件是 a-- > 0
第一次循环:
执行 --b: b变为-1
判断 a-- > 0: a=2>0为true, a减1变为1
- 第二次循环:
执行 --b: b变为-2
判断 a-- > 0: a=1>0为true, a减1变为0
- 第三次循环:
执行 --b: b变为-3
判断 a-- > 0: a=0>0为false, 循环结束
因此，循环执行了3次，最终b的值为-3，所以C是正确答案。
分析其他选项：
A(-1)错误：这只是第一次循环的结果
B(-2)错误：这只是第二次循环的结果
D(死循环)错误：由于a会不断自减，最终会小于等于0，循环会结束，不会发生死循环
21.a=(b=4)+(c=6) 是一个合法的赋值表达式。请问这句话的说法是正确的吗？
A正确 B错误
正确答案：A
官方解析：这道题目考察了C语言中连续赋值表达式的合法性。a=(b=4)+(c=6)确实是一个合法的赋值表达式，因此A选项正确。
让我们来分析这个表达式：
在C语言中，赋值表达式本身也具有值，其值就是被赋的值
表达式从右向左执行：
c=6 执行后，c的值为6，表达式值为6
b=4 执行后，b的值为4，表达式值为4
4+6=10
最后a被赋值为10
执行完后：
a的值为10
b的值为4
c的值为6
这种写法虽然合法，但在实际编程中不推荐使用，因为：
代码可读性差
容易造成混淆
不利于后期维护
所以虽然这种写法在语法上是完全正确的，但在编码规范中通常建议将多个赋值操作分开写，使代码更清晰。
B选项错误，因为该表达式完全符合C语言语法规则，是合法的赋值表达式。
22.以下程序的输出结果为（）。
|----------------------|------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 |#include<stdio.h>#define ADD(x) x*xmain( ){ ``inta=4,b=6,c=7,d=ADD(a+b)*c;printf``(``"d=%d"``,d);}|Ad=70 Bd=80 Cd=140 Dd=700
正确答案：A
官方解析：这道题考察了宏定义展开和运算符优先级的知识点。让我们来逐步分析计算过程：
- 程序中定义了宏 ADD(x) = x*x
所以 d=ADD(a+b)*c 会被展开为: d=(a+b)*(a+b)*c
- 代入数值:
a=4, b=6, c=7
d=(4+6)*(4+6)*7
d=10*10*7
- 计算结果:
10*10=100
100*7=70
因此 d=70，A选项正确。
分析其他选项:
B选项(d=80)错误:可能是误以为宏展开后是(a+b)^2*c直接计算
C选项(d=140)错误:可能是简单地计算了(a+b)*c=10*7=70,然后乘2
D选项(d=700)错误:可能是认为宏展开后直接计算(a+b)*c=70,再乘10
这道题的关键在于:
理解宏是简单的文本替换,ADD(a+b)会被替换为(a+b)*(a+b)
注意运算符优先级,要按照数学运算规则依次计算
不要被宏定义的形式迷惑,要关注实际的展开效果
23.未初始化的全局变量放在下面哪个段中（）
Atext Bdata Cvariable Dbss
正确答案：D
官方解析：在程序的内存分配中,未初始化的全局变量会被放在bss段(Block Started by Symbol)中。bss段专门用来存放未初始化的全局变量和静态变量,这些变量在程序加载时会被自动初始化为0。
分析其他选项:
A错误:text段用于存放程序的代码/指令,不存放变量。
B错误:data段用于存放已初始化的全局变量和静态变量。
C错误:variable不是一个标准的程序段名称。程序的主要段包括text、data、bss等。
补充说明:
bss段不占用可执行文件的空间,只在运行时占用内存
将未初始化的变量统一放在bss段并自动初始化为0,可以减小可执行文件大小
这种内存分段机制是程序编译和加载过程的重要组成部分
了解各个段的作用对理解程序的内存布局很重要
24.对于C语言，下面说法正确的是（）
Awhile 循环语句的执行效率比 do-while 循环语句的执行效率高
Bwhile 循环语句的循环体执行次数比循环条件的判断次数多 1，而do-while 语句的循环体执行次数比循环条件的判断次数少 1
Cwhile 语句的循环体执行次数比循环条件的判断次数少 1，而 do-while语句的循环体执行次数比循环条件的判断次数多 1
Dwhile 语句的循环体执行次数比循环条件的判断次数少 1，而 do-while语句的循环体执行次数等于循环条件的判断次数
正确答案：D
你的答案：B
官方解析：while语句和do-while语句的主要区别在于循环条件的判断时机。D选项正确地描述了这两种循环语句执行特点的区别。
对于while语句:
先判断循环条件
如果条件为真,则执行循环体
循环体执行完后再判断条件
因此while语句的循环条件判断次数总是比循环体执行次数多1次
对于do-while语句:
先执行循环体
然后判断循环条件
如果条件为真,继续执行循环体
所以do-while语句的循环条件判断次数等于循环体执行次数
分析其他选项:
A错误:这两种循环语句的执行效率基本相同,主要区别在于执行逻辑不同
B错误:描述与实际情况相反,while语句的循环体执行次数比条件判断少1次
C错误:对while语句描述正确,但对do-while语句描述错误,do-while的循环体执行次数等于条件判断次数
所以D选项准确描述了这两种循环语句的执行特点。
25.以下代码执行后，it的数据为（）
|-------|-------------------------------------------------------------------------------------------|
| 1 2 3 |std::list<``int``> temp;std::list<``int``>::iterator it = temp.begin();it = --it;|A未知 Btemp.end() C异常 DNULL
正确答案：C
你的答案：A
官方解析：这道题目考察了C++ STL中list容器迭代器的操作特性。
当对一个空list容器temp执行--it操作时会产生未定义行为(undefined behavior),因为试图将迭代器移动到begin()之前的位置是非法的,这会导致异常。所以C是正确答案。
具体分析:
std::list temp创建了一个空的list容器
iterator it = temp.begin()使it指向容器起始位置
由于容器为空,begin()和end()指向同一位置
对it执行自减操作(--it)试图访问begin()之前的位置,这是非法的
这种操作会导致程序崩溃或抛出异常
其他选项分析:
A(未知)错误:结果不是未知,而是一定会导致异常
B(temp.end())错误:自减操作不会使迭代器指向end()位置
D(NULL)错误:list的迭代器不会是NULL值,迭代器是一个对象而不是指针
这提醒我们在使用STL容器迭代器时要特别注意边界条件的处理,确保迭代器的操作都在有效范围内。
26.阅读以下程序，当输入数据的形式为12a345b789↙，正确的输出结果为（）
|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 |intmain() {``charc1,c2;``inta1,a2;``c1 = ``getchar``();``scanf``(``"%2d"``,&a1);``c2 = ``getchar``();``scanf``(``"%3d"``,&a2);``printf(``"%d,%d,%c,%c\n"``,a1,a2,c1,c2);}|A2,345,1,a
B12,345,a,b
C2a,45b,1,3
D2,789,1,a
正确答案：A
官方解析：
【解释】通过调用getchar函数将输入的第一个字符赋给c1,所以c1的值是字符'1'，
接下来调用scanf函数将输入的两位数赋给整型变量a1，但此时输入的两位是2a，a是无
效的数字，所以只将2赋给变量a1，字符'a'通过后续的getchar函数将其赋给变量c2，再
接下来调用scanf函数将输入的三位数赋给整型变量a2，则a2的值为345。所以正确答
案是A。
27.对于下面的说法，正确的是____。
A对于 struct X { short s; int i; char c; }，sizeof(X) 的值等于 sizeof(s) + sizeof(i) + sizeof(c)
B对于某个double变量 a，可以使用 a == 0.0 来判断其是否为零
C初始化方式 char a[14] = "Hello, world!"; 和初始化方式 char a[14]; a = "Hello, world!"; 的效果相同
D在gcc编译器下，对于 int i = 3; printf("%d %d", ++i, ++i)，运行输出为：4 5
E选项A、B、C、D中至少有两个是正确的
F以上选项均不正确
正确答案：F
你的答案：D
官方解析：选项F"以上选项均不正确"是正确答案。让我们逐一分析每个选项：
A选项错误：
对于struct结构体，由于内存对齐机制的存在，sizeof(X)的值通常会大于各成员大小之和。编译器会在成员之间插入填充字节以满足对齐要求，因此sizeof(X)实际值会大于sizeof(s) + sizeof(i) + sizeof(c)。
B选项错误：
由于浮点数在计算机中存在精度问题，直接使用==比较浮点数是不可靠的。正确的做法是检查两个浮点数的差的绝对值是否小于一个很小的阈值，例如：fabs(a - 0.0) < 1e-10。
C选项错误：
这两种初始化方式完全不同。第一种方式char a[14] = "Hello, world!"是合法的数组初始化。第二种方式char a[14]; a = "Hello, world!"是错误的，因为数组名不能作为赋值操作的左值。
D选项错误：
对于printf("%d %d", ++i, ++i)这样的表达式，涉及到未定义行为(undefined behavior)。参数的求值顺序在C语言中没有明确规定，不同编译器可能产生不同结果，甚至同一编译器在不同优化级别下也可能产生不同结果。
E选项错误：
因为A、B、C、D选项都是错误的，所以不可能有两个或以上的选项是正确的。
因此，只有F选项"以上选项均不正确"是正确的。
28.有以下程序
|-------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 |#include <stdio.h>main() {``int a[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10``, ``11``, ``12``}, *p = a + ``5``, *q = NULL;``*q = *(p+``5``);``printf(``"%d %d\n"``, *p, *q);}|程序运行后的输出结果是（）
A运行后报错 B6 6 C6 11 D5 10
正确答案：A
你的答案：C
官方解析：这道题涉及C语言中指针的使用和空指针的概念。代码中的关键问题是对空指针的解引用操作。
关键分析：
程序中定义了一个整型数组a和两个指针p、q
p被初始化为指向数组a的第6个元素（a+5）
q被初始化为NULL（空指针）
程序试图通过*q = *(p+5)给空指针q指向的位置赋值
q是空指针(NULL)，当程序执行到*q = *(p+5)这一行时，试图向空指针指向的内存位置写入数据，这是一个非法操作。在大多数操作系统中，这样的操作会导致段错误(Segmentation Fault)，程序会崩溃。因此A选项"运行后报错"是正确答案。
分析其他选项：
B选项(6 6)错误：程序根本无法执行到printf语句就会崩溃。
C选项(6 11)错误：同样因为程序会在之前崩溃。
D选项(5 10)错误：既计算结果不正确，且程序也无法执行到这一步。
这个题目也提醒我们在实际编程中要特别注意：
使用指针前必须确保指针已经指向了合法的内存地址
要避免对空指针的解引用操作
在使用指针时应该养成先判断指针是否为NULL的好习惯
29.以下代码编译有错误，哪个选项能解决编译错误？
|-------------------|------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 |classA {``public``:``intGetValue() ``const{``vv = 1;``returnvv;``}``private``:``intvv;};|A改变成员变量"vv"为"mutable int vv"
B改变成员函数"GetValue"的声明，以使其不是const的
C都不能修复编译错误
D都可以修复编译错误
正确答案：D
你的答案：B
官方解析：这道题目考察了C++中const成员函数和mutable关键字的概念。D选项是正确的,因为题目中的编译错误可以通过两种方式解决。
产生编译错误的原因是:在const成员函数中试图修改普通成员变量vv的值。const成员函数承诺不会修改对象的状态,因此不允许在其中修改成员变量。
解决方案分析:
A选项:将vv声明为mutable int vv是可行的。mutable关键字允许const成员函数修改被其修饰的成员变量,这是一个合法的解决方案。
B选项:移除GetValue()函数声明中的const修饰符也是可行的。这样该函数就变成了普通成员函数,可以自由修改成员变量。
C选项:错误,因为A和B都是有效的解决方案。
D选项:正确,因为上述两种方案都可以解决这个编译错误。
补充说明:
使用mutable的场景通常是当某个成员变量的修改不影响对象的逻辑状态时,比如缓存、计数器等
移除const修饰符的方案虽然可行,但可能违背最初设计该函数为const的初衷
在实际开发中,应该根据具体的业务需求来选择合适的解决方案
30.下列说法正确的有（）
Aext4文件系统是带有日志功能的文件系统，关闭日志可以使掉电重启消耗的时间缩短
B内存的堆栈中，栈是有系统自动分配的，先入后出；堆是由程序分配的，先入先出。
C创建symbol link会产生新的inode，hard link 不会。
D在C语言中，i++操作不是原子操作。
E以上全都不正确
正确答案：CD
你的答案：BCD
官方解析：让我们逐个分析每个选项:
C选项正确:创建软链接(symbolic link)确实会产生新的inode,而创建硬链接(hard link)不会产生新的inode。硬链接本质上是同一个文件的不同引用,共享同一个inode。
D选项正确:在C语言中,i++操作确实不是原子操作。它实际上包含了三个步骤:读取i的值、将值加1、将结果写回i。在多线程环境下可能会导致竞态条件。
分析错误选项:
A选项错误:虽然ext4文件系统确实带有日志功能,但关闭日志不会缩短掉电重启时间。相反,日志功能是为了保证文件系统的一致性,在掉电重启时能够更快地恢复系统。
B选项错误:关于内存的堆栈描述有误。虽然栈确实是系统自动分配的,但堆并非先入先出。堆是一种动态分配的内存区域,可以任意顺序地分配和释放,没有固定的出入顺序。
E选项错误:因为C和D是正确的,所以"以上全都不正确"的说法显然是错误的。
这道题目主要考察了文件系统、内存管理和并发编程等操作系统的基础知识。