Day11_刷题niuke20250610
试卷01
单选题
C语言
1.
while(1) {x++;}, 当x的取合适的初值时，可以避免死循环。
A
正确
B
错误
正确答案：B
官方解析：while(1){x++;}表示一个无限循环,无论x的初值取多少,只要循环体内是x++这样的自增操作,这个循环就会永远执行下去,不会结束。
因为:
1. x++操作只是让x的值不断增加
2. while(1)中的条件1是一个永远为真的常量
3. 循环的终止与x的值完全无关
4. 循环条件1不会因为x的改变而变成假
所以无论x取什么初值,这个循环都会一直执行下去。这就是典型的死循环结构,没有任何终止条件。
A选项错误,认为通过选择合适的x初值可以避免死循环,这种说法是不正确的。
要避免死循环,需要:
1. 在循环条件中加入与x相关的判断
2. 或者在循环体内添加break等跳出语句
3. 仅仅改变x的初值是无法避免死循环的
因此B选项正确,指出了这种说法的错误之处。这也提醒我们在编程时要注意避免死循环的产生。知识点：C语言
题友讨论(21)
单选题
C++
C语言
2.
以下哪项可以用来释放p=malloc（）分配的内存：
A
free(p)
B
delete p
C
delete []p
D
sizeof p
正确答案：A
官方解析：malloc()是C语言中的内存分配函数,与之对应的内存释放函数是free()。因此A选项free(p)是正确的释放malloc()分配内存的方法。
分析其他选项:
B选项delete p错误:delete是C++中释放new分配的单个对象的内存的操作符,不能用于释放malloc分配的内存。
C选项delete []p错误:delete[]是C++中释放new[]分配的数组内存的操作符,同样不能用于释放malloc分配的内存。
D选项sizeof p错误:sizeof是运算符,用于获取数据类型或变量的字节大小,完全不具备释放内存的功能。
补充说明:
- malloc/free是C语言的库函数
- new/delete是C++的操作符
- 必须配对使用malloc/free或new/delete,不能交叉使用
- 使用malloc分配的内存必须使用free释放
- 使用free释放内存后,指针p变成悬空指针,最好将p置为NULL知识点：C++、C语言
题友讨论(9)
单选题
C++
C语言
3.
有以下定义：
int a[10];
char b[80];
函数声明为：
void sss(char[],int[]);
则正确的函数调用形式是（）。
A
sss(a,b);
B
sss(char b[],int a[]);
C
sss(b[],a[]);
D
sss(b,a);
正确答案：D
官方解析：考察了C语言中函数调用的语法规则。D选项 sss(b,a) 是正确的函数调用形式。
在函数调用时,数组名就代表数组的首地址。根据函数声明 void sss(char[],int[]), 第一个参数需要传入字符数组,第二个参数需要传入整型数组。而b是char[80]类型的数组名,a是int[10]类型的数组名,直接使用数组名b和a作为参数进行调用即可。
分析其他选项的错误原因:
A错误:sss(a,b)颠倒了参数顺序,不符合函数声明中参数类型的要求
B错误:sss(char b[],int a[])是函数声明的形式而不是调用形式
C错误:sss(b[],a[])语法错误,函数调用时不能在数组名后加[]
总的来说,在C语言中调用带数组参数的函数时,直接使用数组名作为实参即可,不需要加[]或指定类型。数组名会自动转换为指向数组首元素的指针传递给函数。D选项正确地体现了这一点。知识点：C++、C语言
题友讨论(17)
单选题
C++
C语言
4.
下面代码运行后,变量 total 的结果是?
1
2
3
4
inttotal = 0;
for(inti = 0, j = 5; total < 10 || j > 3; ++i, --j) {
total += (i + j);
}A
5
B
10
C
无法通过编译
D
运行时出错
E
运行时死循环
正确答案：B
官方解析：让我们来模拟代码的执行过程:
循环中的total累加计算过程如下:
第1次: i=0, j=5, total+=5, total=5
第2次: i=1, j=4, total+=5, total=10
此时total=10, j=4>3, 继续执行
第3次: i=2, j=3, total+=5, total=15
循环终止条件是 total<10 || j>3，即total小于10或j大于3。当第二次循环结束时，total=10，j=4，此时虽然total>=10，但是j>3仍然成立，所以会继续循环。当第三次循环结束后，total=15，j=3，两个条件都不满足，循环结束。
因此final结果total=10是正确的。
分析其他选项:
A错误:5是第一次循环后的结果,不是最终结果
C错误:代码可以正常编译,语法完全正确
D错误:代码可以正常运行,不会出现运行时错误
这道题目主要考察:
1. for循环的条件判断逻辑(使用||运算符)
2. 多变量循环控制
3. 变量累加计算
4. 循环终止条件的判断
需要注意循环条件中使用了逻辑或运算符||,只要有一个条件满足就会继续循环。这是很多人容易忽视的细节。知识点：C++、C语言
题友讨论(31)
单选题
C语言
5.
若以下说明语句:char x; float y; double z;
则表达式x-y+z的类型为（） 。
A
int
B
double
C
float
D
char
正确答案：B
官方解析：这道题目考察的是C语言中不同数据类型进行混合运算时的类型转换规则。
在表达式 x-y+z 中涉及了char、float和double三种不同的数据类型，根据C语言的自动类型转换规则：
1. 运算过程中较小数据类型会自动向较大数据类型转换
2. 数据类型按精度从低到高排序为: char < int < float < double
因此在计算过程中：
- char类型的x会先转换为float与y进行运算
- float类型的结果再与double类型的z进行运算
- 最终表达式的结果类型会自动提升为精度最高的double类型
所以B选项double是正确答案。
分析其他选项：
A(int)错误：虽然char会自动转换为int，但最终结果会是double类型
C(float)错误：float的精度低于double，最终结果会自动提升为double
D(char)错误：char是最低精度类型，不可能作为混合运算的最终类型
即使没有明确的类型转换，C语言会自动进行隐式类型转换，确保运算结果的精度不会降低。这种自动转换机制被称为"算术转换"。知识点：C语言
题友讨论(11)
单选题
C语言
6.
以下选项中可用作 C 语言合法用户标识符的是
A
2a
B
void
C
-abc
D
_123
正确答案：D
官方解析：C语言标识符的命名规则规定:标识符只能由字母、数字和下划线组成,且第一个字符必须是字母或下划线。D选项_123完全符合这些规则,因此是合法的标识符。
分析其他选项:
A选项(2a):以数字开头,违反了标识符首字符必须是字母或下划线的规则。
B选项(void):void是C语言的关键字,不能用作标识符。关键字是语言本身用于特定用途的保留字。
C选项(-abc):包含了特殊字符减号(-),而C语言标识符中只允许出现字母、数字和下划线。
综上所述:
- 只有D选项(_123)完全遵循了C语言标识符的命名规则
- 其他选项都违反了标识符命名的某项基本规则
- 在实际编程中,建议选择有意义的标识符名称,虽然_123是合法的,但从代码可读性角度来说并不是最佳选择知识点：C语言
题友讨论(0)
单选题
C语言
7.
一个C程序的执行是从（ ）
A
本程序的main函数开始,到main函数结束
B
本程序文件的第一个函数开始,到本程序文件的最后一个函数结束
C
本程序的main函数开始,到本程序文件的最后一个函数结束
D
本程序文件的第一个函数开始,到本程序main函数结束
正确答案：A
你的答案：C
官方解析：调用函数可能在最后
知识点：C语言
题友讨论(2)
单选题
C语言
8.
以下叙述中正确的是（）
A
书写源程序时，必须注意缩进格式，否则程序会有编译错误
B
程序的主函数名除main外，也可以使用Main或_main
C
程序可以包含多个主函数，但总是从第一个主函数处开始执行
D
在C程序中，模块化主要是通过函数来实现的
正确答案：D
官方解析：解析 ：【解析】C语言的源程序中对缩进没有要求,所以A选项错误。C语言中区分大小写,main函数不能写成Main或_main,所以B选项错误。一个C程序有且只有一个主函数,所以C选项错误。
知识点：C语言
题友讨论(1)
单选题
C++
C语言
9.
以下哪个属于在预编译阶段执行____,以下哪些指令属于操作符___
a:malloc;
b:++;
c:#pragma;
d:sizeof;
e:#define
A
预编译c,e 操作符a,b
B
预编译c,d 操作符b,e
C
预编译c,e 操作符b,d
D
预编译a,d 操作符b,d
正确答案：C
官方解析：这道题目考察了C语言中预编译指令和操作符的概念。C选项正确,因为#pragma和#define属于预编译指令,而++和sizeof属于操作符。
具体分析:
预编译指令:
- #pragma: 用于向编译器发出特定的指令
- #define: 用于宏定义,在预编译阶段进行文本替换
- 这些指令都是在预编译阶段处理的
操作符:
- ++ : 自增运算符
- sizeof: 用于计算数据类型或变量的字节大小的运算符
- 这些是在程序执行时进行实际运算的操作符
分析其他选项错误原因:
A错误:malloc不是操作符,它是一个内存分配函数
B错误:将e(#define)错误地归类为操作符
D错误:malloc和sizeof都不属于预编译指令,malloc是函数,sizeof是操作符
总结:预编译指令都是以#开头的,在程序编译前就会被处理;而操作符是在程序运行时用于执行特定运算的符号。理解这个基本概念可以帮助我们正确区分它们。知识点：C++、Java工程师、C++工程师、运维工程师、前端工程师、算法工程师、PHP工程师、2016、C语言
题友讨论(15)
单选题
Java
C语言
10.
设int x=1,float y=2,则表达式x/y的值是：（）
A
0
B
1
C
2
D
以上都不是
正确答案：D
官方解析：这道题目考察了不同数据类型之间的运算规则和隐式类型转换。
当int类型的x(值为1)除以float类型的y(值为2)时，会发生以下过程：
1. 首先，按照Java的类型提升规则，int类型的x会被自动转换为float类型
2. 然后进行float类型的除法运算：1.0f / 2.0f = 0.5f
因此x/y的结果是0.5，这个值不在选项A(0)、B(1)、C(2)中，所以D(以上都不是)是正确答案。
分析其他选项：
A选项(0)错误：除法运算结果是0.5而不是0
B选项(1)错误：除法运算结果是0.5而不是1
C选项(2)错误：除法运算结果是0.5而不是2
需要注意的是，在涉及不同数据类型运算时，较小精度的类型会自动提升为较大精度的类型，然后再进行运算。这里int类型提升为float类型后再进行除法运算，得到的结果也是float类型的0.5。知识点：Java、C语言
题友讨论(115)
单选题
C++
C语言
11.
不合法的main函数命令行参数表示形式是__________
A
main(int a, char *c[])
B
main(int arc, char **arv)
C
main(int argc, char *argv)
D
main(int argv, char *argc[])
正确答案：C
官方解析：main函数的命令行参数有标准格式要求,C选项中的写法"main(int argc, char *argv)"是不合法的,因为:
1. argv需要是一个指向字符串数组的指针,正确写法应该是"char *argv[]"或"char **argv"
2. 这种形式无法正确表示字符串数组参数
分析其他选项:
A选项"main(int a, char *c[])"是合法的:
- a表示参数个数
- c[]表示字符串数组,用于存储参数
B选项"main(int arc, char **arv)"是合法的:
- arc表示参数个数
- char **arv表示指向字符串数组的指针
D选项"main(int argv, char *argc[])"虽然形式上正确,但参数名称使用不恰当:
- 通常argv用于表示参数数组
- argc用于表示参数个数
但这只是命名习惯问题,语法本身是合法的
所以标准的main函数命令行参数形式应该是:
1. main(int argc, char *argv[])
2. main(int argc, char **argv)
这两种写法是等价的。知识点：C++、C语言
题友讨论(13)
单选题
C语言
12.
下面代码段的输出是（）
1
2
3
4
intmain() {
inta=3;
printf("%d\n",(a+=a-=a*a));
}
A
-6
B
12
C
0
D
-12
正确答案：D
官方解析：
【解释】a+=a-=a*a等价于a=a+(a=a-a*a)，即先计算a=a-a*a，所以此时
a的值为3-3*3=-6，再计算-6+（-6）=-12赋值给a，所以a的值为-12，也就是整
个表达式的值，所以应选择D。
知识点：C语言
题友讨论(9)
单选题
C语言
13.
以下程序运行的结果是（）
1
2
3
4
5
6
7
#define X 5
#define Y X+1
#define Z Y*X/2
intmain() {
inta = Y;
printf("%d,%d", Z, --a);
}
A
7,6
B
12,6
C
12,5
D
7,5
正确答案：D
官方解析：
【解释】先来计算Z的值，Z将替换成Y*X/2，再把X+1替换Y，得Z=X+1*
X/2，再用5替换X，得Z=5+1*5/2，所以Z的值是7（注意整除）。a=Y宏替换后
变成a=X+1，再将5替换X，得a=5+1，即a的值是6，但输出是--a，a先减1即
变为5，再输出。故正确答案是D。
知识点：C语言
题友讨论(21)
单选题
C语言
14.
若有定义：char *p(char a[10]);则p是函数名。（）
A
正确
B
错误
正确答案：A
你的答案：B
官方解析：这道题涉及到C语言中的函数声明语法。声明中的 char *p(char a[10]) 确实表明p是一个函数名，因为这是一个函数声明的语法格式。
具体分析：
1. char *p(char a[10]) 这个声明表示:
- p是一个函数名
- 该函数接收一个字符数组作为参数
- 函数返回值类型是字符指针(char*)
2. 这种声明方式遵循C语言的函数声明语法规则：
返回值类型 函数名(参数列表)
3. 括号()的存在明确表明这是一个函数声明，而不是指针变量声明。如果是指针变量声明，语法会是不同的，例如：char (*p)[10]
4. a[10]是参数，表示接收一个大小为10的字符数组
所以A选项"正确"是对的，这就是一个典型的函数声明，其中p确实是函数名。而B选项"错误"显然不对，因为这完全符合C语言的函数声明语法规范。
这个知识点在C语言编程中很重要，因为它涉及到函数声明的基本语法，对于理解指针和函数的关系也很有帮助。知识点：C语言
题友讨论(10)
单选题
C++
C语言
15.
设有以下定义：
1
2
inta[4][3] = {1,2,3,4,5,6,7,8,9,10,11,12};
int(*prt)[3] = a, *p = a[0];则以下能够正确表示数组元素a[1][2]的表达式是（）
A
* (( * prt+1)[2])
B
* ( * (p+5))
C
( * prt+1)+2
D
* ( * (a+1)+2)
正确答案：D
官方解析：这道题目考察了C语言中指针和二维数组的基本概念以及它们之间的关系。
数组a[4][3]是一个4行3列的二维数组，prt是指向含3个元素一维数组的指针，p是指向第一个元素的指针。要访问a[1][2]，需要正确理解指针运算。
D选项 *(*(a+1)+2) 是正确的，分析如下：
- a+1 表示指向第二行（即下标为1的行）的起始位置
- *(a+1) 得到第二行的首地址
- *(a+1)+2 表示第二行往后偏移2个位置
- 最外层的*操作取得该位置的值，正好是a[1][2]
分析其他选项：
A. *((*prt+1)[2]) 语法错误，指针运算顺序有误
B. *(*(p+5)) 虽然在内存地址上可能指向正确位置，但这种表达方式不符合二维数组的访问规范
C. (*prt+1)+2 少了最外层的解引用操作，只是得到了地址而不是值
需要注意的要点：
1. 二维数组名a本质上是指向一维数组的指针
2. 指针运算要考虑步长
3. 解引用操作(*)的使用位置会影响最终结果知识点：C++、C语言
题友讨论(21)
单选题
C语言
16.
关于C语言中volatile关键字，下面的说法哪一个是错误的？
A
编译器会禁止对volatile修饰的变量进行读写优化
B
用volatile修饰的变量，读取速度会更快
C
每一次读取volatile修饰的变量都会从内存中读取
正确答案：B
你的答案：C
官方解析：volatile关键字是C语言中的一个重要修饰符，用于防止编译器对变量访问进行优化。B选项错误，因为使用volatile修饰的变量读取速度实际上会更慢，而不是更快。
原因如下：
1. volatile修饰的变量每次都必须从内存中重新读取，而不能使用寄存器中的值
2. 这样会绕过CPU缓存，直接从主存读取，增加了访问延迟
3. 编译器也不能对其进行任何优化，因此无法利用优化带来的性能提升
分析其他选项：
A正确：volatile确实会禁止编译器优化。编译器不能将volatile变量缓存到寄存器中，每次访问都要从内存重新读取。
C正确：这是volatile的核心特性之一。由于某些变量可能被其他线程或硬件修改，每次读取都直接从内存中获取最新值可以确保程序访问到的始终是最新数据。
总的来说，volatile牺牲了性能来换取数据的正确性，主要用于多线程编程或硬件寄存器访问等场景，而不是用来提升性能。知识点：C语言
题友讨论(14)
单选题
C++
C语言
17.
1
2
3
4
5
6
7
enumstring{
x1,
x2,
x3 =10,
x4,
x5,
} x;函数外部访问x等于什么？
A
5
B
12
C
0
D
随机值
正确答案：C
你的答案：B
官方解析：这道题考察了C++中枚举类型(enum)的基本概念和特性。枚举类型string定义了一个变量x,在函数外部访问x的值为0。
分析原因如下:
1. 枚举类型中,第一个枚举常量默认值为0,后续的枚举常量值依次加1
2. 在这个枚举定义中:
- x1的值为0
- x2的值为1
- x3被显式指定为10
- x4的值为11(x3+1)
- x5的值为12(x4+1)
3. 变量x是该枚举类型的一个对象,当枚举变量没有显式初始化时,它会被自动初始化为枚举列表中的第一个枚举常量的值,即x1的值0。
分析其他选项:
A错误:5不是任何枚举常量的值
B错误:12是x5的值,但不是x的值
D错误:枚举变量未初始化时会有确定的值(第一个枚举常量的值),不会是随机值
因此,在函数外部访问x的值等于0,选项C是正确的。知识点：C++、C语言
题友讨论(127)
单选题
C++
C语言
18.
k为unsigned int类型，以下while循环执行次数为（）
1
2
3
unsignedintk =20;
while(k >=0)
--k;A
20次
B
一次也不执行
C
死循环
D
21次
正确答案：C
你的答案：D
官方解析：这道题目考察了无符号整数(unsigned int)与有符号整数(int)的比较运算以及循环条件的判断。
这段代码会形成死循环,原因如下:
1. k被声明为unsigned int类型,而unsigned int是无符号整数,其取值范围是[0, 4294967295]
2. while循环的条件"k >= 0"永远为true,因为unsigned int类型的数永远大于或等于0
3. 即使k通过--k运算不断减1,当k从0减1时,由于unsigned int的特性,k会变成4294967295(2^32-1)
4. 因此k永远不可能小于0,循环条件始终为true,形成死循环
分析其他选项:
A错误:不会只执行20次,因为是死循环
B错误:循环条件一开始就满足(20>=0),所以循环会执行
D错误:不会只执行21次,因为是死循环
这个问题也说明了在进行数值比较时,要特别注意有符号数和无符号数的区别,避免因类型不匹配导致的逻辑错误。知识点：C++、C语言
题友讨论(36)
单选题
C++
C语言
19.
若有定义：
char s[3][4];
则下列对数组元素s[i][j]的各种引用形式中，正确的是（）
A
* (s+i)[j]
B
* (&s[0][0]+4 * i+j)
C
* ((s+i)+j)
D
* ( * (s+i)[j])
正确答案：B
你的答案：A
官方解析：在这道题目中,需要理解二维数组的元素访问方式。B选项是正确的,让我们逐一分析:
首先明确 char s[3][4] 是一个3行4列的二维字符数组。在内存中是连续存储的,每个元素占1个字节。
B选项 *((&s[0][0]+4*i+j)) 正确:
- &s[0][0] 获取数组首元素地址
- 4*i 表示跳过i行(每行4个元素)
- +j 表示在当前行偏移j个位置
- 最后解引用得到元素值
分析其他错误选项:
A. *(s+i)[j] 错误:
s+i 得到第i行首地址,但后面的[j]语法有误,会导致指针运算错误
C. *((s+i)+j) 错误:
s+i 得到第i行地址,但直接+j会产生错误的指针运算,因为行指针不能直接加偏移量j
D. *(*(s+i)[j]) 错误:
语法结构有误,*(s+i)[j]已经是错误的,再次解引用会更错
这个题目主要考察了:
1. 二维数组的内存布局
2. 指针运算
3. 数组元素访问的不同表达方式
只有B选项正确地反映了二维数组元素访问的内存偏移计算方式。知识点：C++、C语言
题友讨论(26)
单选题
数组
C语言
C++
20.
以下选项中，在C/C++中正确定义二维数组的是哪个选项（）
A
char a[2][2] = 'a', 'b', 'c', 'd';
B
int a[][] = {{1, 2, 3}, {4, 5, 6}};
C
int a[2][] = {1, 2, 3, 4, 5, 6};
D
int a[][4] = {1, 2, 3, 4, 5, 6};
正确答案：D
官方解析：在C/C++中定义二维数组时需要明确指定数组的维度。D选项 int a[][4] = {1, 2, 3, 4, 5, 6} 是正确的定义方式，因为它指定了列数(4)，而行数可以根据初始化的元素个数自动推导。
分析其他选项的错误原因：
A选项：char a[2][2] = 'a', 'b', 'c', 'd' 的语法错误。正确的初始化方式应该是使用大括号，如 char a[2][2] = {{'a', 'b'}, {'c', 'd'}}。
B选项：int a[][] = {{1, 2, 3}, {4, 5, 6}} 错误，因为声明二维数组时至少需要指定一个维度（通常是列数）。不能两个维度都省略。
C选项：int a[2][] = {1, 2, 3, 4, 5, 6} 错误，在C/C++中不允许只指定行数而省略列数。这种写法在Java中是允许的，但在C/C++中是非法的。
在二维数组的声明中，如果要省略维度，只能省略第一个维度（行数），而第二个维度（列数）必须明确指定。这样编译器才能正确计算数组元素的存储位置。D选项正确地遵循了这一规则。知识点：C++、数组、C语言
题友讨论(24)
单选题
C语言
21.
字符串"//＾▽＾//\n"的长度是（）
A
6
B
7
C
8
D
9
正确答案：C
官方解析：字符串"//＾▽＾// "的长度是8字符。让我们来逐个分析每个字符：
1. 第一个"/" - 1个字符
2. 第二个"/" - 1个字符
3. "＾" - 1个字符(全角字符也算1个字符)
4. "▽" - 1个字符
5. "＾" - 1个字符
6. 第三个"/" - 1个字符
7. 第四个"/" - 1个字符
8. " " - 1个字符(换行符算1个字符)
所以总共是8个字符，C选项正确。
分析其他选项：
A选项(6)：错误，漏计了部分字符
B选项(7)：错误，少计了1个字符
D选项(9)：错误，多计了1个字符
需要注意的是：
- 全角字符(如＾)在字符串长度计算中也是按1个字符计算
- 特殊符号(如▽)也是按1个字符计算
- 转义字符( )虽然是用两个符号表示，但在字符串中只占1个字符长度知识点：C++工程师、2017、C语言
题友讨论(40)
单选题
C语言
22.
若int 占 2 个字节， char 占 1 个字节， float 占 4 个字节， sizeof(xc) 大小是：
1
2
3
4
5
6
7
8
structstu {
union{
charbj[5];
intbh[2];
} _class;
charxm[8];
floatcj;
}xc;A
16
B
18
C
22
D
20
正确答案：D
官方解析：根据题目所给条件,需要计算结构体stu的大小。让我们逐步分析各个成员的内存占用情况:
1. union class的大小:
- char bj[5]占5字节
- int bh[2]占4字节(int占2字节×2)
由于联合体的大小是其最大成员的大小,所以class占5字节
2. char xm[8]占8字节
3. float cj占4字节
4. 考虑内存对齐:
- 结构体起始位置要对齐
- union class占5字节,会补齐到6字节(2的倍数)
- char数组占8字节,不需补齐
- float占4字节,其起始位置需要4字节对齐,因此前面可能需要填充2字节
所以总大小为:6 + 8 + 2 + 4 = 20字节
因此D选项20是正确答案。
分析其他选项:
A(16)错误:没有考虑内存对齐的要求
B(18)错误:计算有误,且不是对齐后的大小
C(22)错误:过大,超出了实际所需的内存空间
理解这道题的关键是要注意:
1. 联合体的大小取决于最大成员
2. 内存对齐的规则
3. 不同数据类型的字节数知识点：C语言
题友讨论(126)
单选题
Java
C语言
23.
正则表达式中，表示匹配非数字字符的字符是（）
A
\b
B
\d
C
\B
D
\D
正确答案：D
官方解析：在正则表达式中，D 是用来匹配任何非数字字符的元字符。它等价于 [^0-9]，表示匹配任何不是数字 0-9 的字符。
分析其他选项：
A: 表示单词边界，用于匹配单词的开始或结束位置，不是用来匹配非数字字符。
B: d 恰好相反，它表示匹配任何数字字符，等价于 [0-9]。
C: B 表示非单词边界，与 相反，也不是用来匹配非数字字符。
选择 D 的理由：
1. D 直接表示"非数字"，这是一个记忆技巧：大写的 D 表示与小写 d 相反的含义
2. 在正则表达式中，通常使用大写字母表示小写字母的补集
3. 例如：匹配字符串 "abc123" 时，D 会匹配到 "abc"，而不会匹配到 "123"
这是正则表达式中的一个基本概念，掌握这些元字符对于编写有效的正则表达式至关重要。知识点：Java、C语言、JavaSE
题友讨论(141)
单选题
C语言
24.
下面这段代码会打印出什么？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
classA {
public:
A() {printf("A"); }
~A() {printf("deA"); }
};
classB {
public:
B() {printf("B"); }
~B() {printf("deB"); }
};
classC :publicA,publicB {
public:
C() {printf("C"); }
~C() {printf("deC"); }
};
intmain() {
A *a =newC();
deletea;
return0;
}
A
A B C deA
B
C A B deA
C
A B C deC
D
C A B deC
正确答案：A
你的答案：D
官方解析：这道题目考察了C++中继承和多态的概念,特别是构造函数、析构函数的调用顺序以及虚析构函数的重要性。
正确答案A(A B C deA)是正确的,分析如下:
1. 构造顺序:
- 派生类构造时,先调用基类构造函数,按照继承声明顺序
- C继承自A、B,所以先构造A,再构造B,最后构造C
- 因此输出顺序是:"A B C"
2. 析构问题:
- 代码中A类的析构函数不是虚析构函数
- 使用基类指针删除派生类对象时,如果基类析构函数不是虚函数,只会调用基类的析构函数
- 所以只输出"deA"
其他选项错误原因:
B选项(C A B deA):构造顺序错误,派生类构造时基类先构造
C选项(A B C deC):析构函数不是虚函数时不会调用派生类析构函数
D选项(C A B deC):既有构造顺序错误,又忽视了非虚析构的问题
这个问题也说明了在使用继承时声明虚析构函数的重要性。如果A的析构函数是虚函数,正确的输出应该是"A B C deC deB deA"。这样才能正确清理派生类对象的资源。知识点：C语言
题友讨论(55)
单选题
C语言
25.
有以下程序
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <string.h>
voidfun(char*s) {
chara[10];
strcpy(a,"STRING");
s = a;
}
main() {
char*p ="PROGRAM";
fun(p);
printf("%s\n", p);
}程序运行后的输出结果是(此处□代表空格)?
A
STRING
B
STRING□□□□
C
STRING□□□
D
PROGRAM
正确答案：D
你的答案：B
官方解析：本题考查字符串指针作为函数参数,本题中p作为字符串指针传入fun中,p指向的内容并没有发生变化,所以选项D正确。
知识点：C语言
题友讨论(62)
单选题
C++
C语言
26.
观察下面一段代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
classClassA {
public:
virtual~ClassA(){};
virtualvoidFunctionA(){};
};
classClassB {
public:
virtualvoidFunctionB(){};
};
classClassC :publicClassA,publicClassB {
public:
};
ClassC aObject;
ClassA *pA = &aObject;
ClassB *pB = &aObject;
ClassC *pC = &aObject;
关于pA,pB,pC的取值,下面的描述中正确的是:A
pA,pB,pC的取值相同.
B
pC=pA+pB
C
pA和pB不相同
D
pC不等于pA也不等于pB
正确答案：C
官方解析：在C++的多重继承中,当一个派生类同时继承多个基类时,不同基类指针指向同一个派生类对象可能会有不同的地址值。这是由于C++对象的内存布局导致的。
在这段代码中,ClassC同时继承了ClassA和ClassB两个基类。当创建ClassC的对象aObject时:
1. pA指向aObject的ClassA部分的起始地址
2. pB指向aObject的ClassB部分的起始地址
3. pC指向整个aObject对象的起始地址
因此C选项"pA和pB不相同"是正确的。这是因为在多重继承的内存布局中,不同基类的虚函数表指针会位于不同的内存位置。
分析其他选项:
A错误:pA、pB、pC的值不可能相同,因为它们指向对象的不同部分。
B错误:pC不等于pA+pB,这种数学运算对指针没有实际意义。指针的值代表内存地址,不能简单相加。
D错误:虽然pC确实不等于pB,但pC通常会等于pA(假设ClassA是第一个基类),因为派生类对象的起始地址通常与第一个基类的地址相同。
这种指针地址不同的特性是C++多重继承实现的重要细节,需要在使用多重继承时特别注意。知识点：C++、C语言
题友讨论(76)
单选题
C++
C语言
27.
以下函数用法正确的个数是：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
voidtest1(){
unsignedchararray[MAX_CHAR+1],i;
for(i = 0;i <= MAX_CHAR;i++){
array[i] = i;
}
}
char*test2(){
charp[] ="hello world";
returnp;
}
char*p = test2();
voidtest3(){
charstr[10];
str++;
*str ='0';
}A
0
B
1
C
2
D
3
正确答案：A
你的答案：B
官方解析：这道题目中的三个函数都存在问题,所以正确答案为0个,选A。
让我们逐个分析:
test1()函数存在的问题:
- 变量i被声明为unsigned char类型,当i增加到MAX_CHAR时再加1会发生溢出
- 这会导致for循环成为死循环,因为i永远不会大于MAX_CHAR
test2()函数存在的问题:
- 函数返回了局部数组p的地址
- p是局部变量,函数返回后这块内存会被释放
- 返回指向已释放内存的指针是危险的,会导致未定义行为
test3()函数存在的问题:
- 试图对数组名str进行自增操作
- 数组名是常量指针,不能进行++操作
- 这是非法的,会导致编译错误
所以这三个函数都存在严重问题,都不是正确的用法。0个正确是恰当的答案。
这道题目主要考察了:
1. 字符类型变量的溢出问题
2. 返回局部变量地址的危险性
3. 数组名的本质及其操作限制
这些都是C/C++编程中的重要陷阱,需要特别注意。知识点：C++、C语言
题友讨论(88)
多选题
C++
C语言
28.
以下变量的定义，正确的是（）
A
int 3man；
B
int i, *pi；
C
int 3man’shoes；
D
short int si；
正确答案：BD
官方解析：这道题目考察了变量定义的基本语法规则。选项BD符合C语言的变量命名规范和定义方式。
B选项"int i, *pi;"是正确的,因为:
- i是一个整型变量
- *pi是一个整型指针变量
- 变量名由字母开头,符合命名规范
- 多个变量可以用逗号分隔在同一行定义
D选项"short int si;"也是正确的,因为:
- short int是合法的数据类型声明
- si是合法的变量名,由字母组成
- 整个声明符合语法规则
分析错误选项:
A选项"int 3man"错误:
- 变量名不能以数字开头,必须以字母或下划线开头
C选项"int 3man'shoes"错误:
- 变量名不能以数字开头
- 变量名中不能包含单引号
- 变量名只能包含字母、数字和下划线
总之,变量的命名必须遵循以下规则:
1. 必须以字母或下划线开头
2. 只能包含字母、数字和下划线
3. 不能使用关键字
4. 区分大小写知识点：2015、C++、C++工程师、C语言
题友讨论(32)
多选题
C语言
29.
以下程序的输出结果是（）
1
2
3
4
5
6
intmain() {
inta[3][3] = {{1, 2}, {3, 4}, {5, 6}}, i, j, s = 0;
for(i = 1; i < 3; i++)
for(j = 0; j <= i; j++) s += a[i][j];
printf("%d\n", s++);
}
A
18
B
19
C
20
D
21
正确答案：A
官方解析：这道题目考察了二维数组和循环的基本知识点。让我们来逐步分析代码执行过程：
1. 首先，定义了一个3×3的二维数组a，初始化值如下：
a[0][0]=1 a[0][1]=2 a[0][2]=0
a[1][0]=3 a[1][1]=4 a[1][2]=0
a[2][0]=5 a[2][1]=6 a[2][2]=0
2. 观察循环条件：
外层循环 i 从1开始到2 (i < 3)
内层循环 j 从0开始到i (j <= i)
3. 计算过程：
当i=1时：
- j=0: s += a[1][0] = 3
- j=1: s += a[1][1] = 3 + 4 = 7
当i=2时：
- j=0: s += a[2][0] = 7 + 5 = 12
- j=1: s += a[2][1] = 12 + 6 = 18
- j=2: s += a[2][2] = 18 + 0 = 18
4. 最后执行printf("%d ", s++)，先输出s的值18，然后s自增
所以A选项18是正确答案。
其他选项错误原因：
B(19)：这是在输出后s自增的值，但题目只问输出结果
C(20)和D(21)：这些值在程序执行过程中不会出现，是完全错误的计算结果知识点：2015、C++工程师、C语言
题友讨论(15)
多选题
C语言
30.
请问下列代码的输出结果有可能是哪些（）？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdint.h>
#include <stdio.h>
unionX {
int32_t a;
struct{
int16_t b;
int16_t c;
};
};
intmain() {
X x;
x.a = 0x20150810;
printf("%x,%x\n", x.b, x.c);
return0;
}A
2015,810
B
50810,201
C
810,2015
D
20150,810
正确答案：AC
你的答案：AB
官方解析：这道题目考察了C++中union(联合体)的内存布局以及大小端(endianness)的概念。
关键点在于:
1. union中所有成员共享同一块内存空间,其大小由最大成员决定
2. 这里x.a是32位整型(4字节),被赋值为0x20150810
3. x.b和x.c各是16位整型(2字节),它们共同占用x.a的空间
4. 输出结果取决于系统的大小端方式:
大端系统下:
- x.b会取高16位(0x2015)
- x.c会取低16位(0x0810)
所以输出为2015,810
小端系统下:
- x.b会取低16位(0x0810)
- x.c会取高16位(0x2015)
所以输出为810,2015
因此可能的输出有两种情况:2015,810或810,2015,即选项A和C。
分析错误选项:
B选项(50810,201):这个拆分方式不符合16位的划分规则
D选项(20150,810):20150超出了16位整型能表示的范围
所以正确答案是AC,这取决于运行系统的大小端方式。知识点：C语言
试卷02
1.
一个可执行的 C 程序的开始执行点是（ ）
A
程序中第一个语句
B
包含文件的第一个函数
C
main()函数
D
程序中的第一个函数
正确答案：C
官方解析：在C语言中,main()函数是程序的入口点(Entry Point),是程序开始执行的地方。当程序运行时,操作系统会自动调用main()函数作为程序执行的起点。
分析各选项:
A错误:程序中的第一个语句并不一定是程序的执行起点。程序中可能包含很多语句,它们的顺序并不决定执行顺序。
B错误:包含文件(如头文件)中的函数只是函数的声明或定义,不是程序的执行起点。
C正确:main()函数是C程序的标准入口点,这是C语言规范所规定的。不管程序中其他函数的位置如何,程序都从main()函数开始执行。
D错误:程序中的第一个函数在源代码中的位置并不重要,程序不一定从第一个定义的函数开始执行。
补充说明:即使在程序中定义了多个函数,程序仍然需要从main()函数开始执行。其他函数只有在被main()函数直接或间接调用时才会执行。这是C语言程序设计的基本原则。知识点：C语言
题友讨论(4)
单选题
C++
C语言
2.
如果函数不需要任何返回值，使用什么形式的函数声明？
A
myfunction()
B
void myfunction()
C
myfunction(void)
正确答案：B
官方解析：在 C 语言中，void myfunction() 是正确的语法格式来声明一个无返回值的函数。void 关键字明确指示该函数不返回任何值。
分析各选项：
B正确：void myfunction() 是标准的无返回值函数声明格式。void 放在函数名前面，清晰地表明这个函数不需要返回值。这种写法符合 C 语言的语法规范，也是最常用的写法。
A错误：myfunction() 这种写法在 C 语言中属于默认返回 int 类型，而不是表示无返回值。这是一种过时的写法，在现代 C 语言编程中应该避免使用。
C错误：myfunction(void) 这种写法中 void 放在参数列表位置，表示该函数不接受任何参数，而不是表示函数无返回值。这个写法用于明确指出函数不接受参数，但并没有说明返回值类型。
补充说明：在实际编程中，为了代码的可读性和明确性，应该使用 void myfunction() 这种标准格式来声明无返回值的函数。这样可以让其他程序员一眼就能看出函数的返回值类型。知识点：C++、C语言
题友讨论(6)
单选题
C语言
3.
C语言规定，函数返回值的类型是由（）
A
return语句中的表达式类型所决定
B
调用该函数时的主调函数类型所决定
C
调用该函数时系统临时决定
D
在定义该函数时所指定的函数类型所决定
正确答案：D
你的答案：A
官方解析：
【解释】函数的返回值的类型是由定义该函数时所指定的数据类型来决定的。所以正
确答案是D。
知识点：C语言
题友讨论(3)
单选题
C++
C语言
4.
以下程序的执行结果是（）
1
2
3
4
5
6
#include<stdio.h>
intmain() {
inti=10,j=10;
printf("%d,%d\n",++i, j--);
return0;
}A
11,10
B
9,10
C
11,9
D
10,9
正确答案：A
官方解析：在这段代码中，涉及到自增(++)和自减(--)运算符的使用，以及它们作为前缀和后缀时的不同效果。
程序输出结果为11,10，A选项正确。这是因为：
1. ++i是前缀自增运算符，它会先将i的值增加1（从10变为11），然后使用这个新值11
2. j--是后缀自减运算符，它会先使用j的当前值10，然后才将j的值减少1（变为9）
3. printf()函数会按照参数从左到右的顺序进行求值
所以在打印时：
- 第一个值是++i的结果，即11
- 第二个值是j--执行前的值，即10
分析其他选项为什么错误：
B选项(9,10)：显然错误，因为++i是先加后用，不可能输出9
C选项(11,9)：错误，因为j--是先用后减，打印时还是10而不是9
D选项(10,9)：错误，因为++i是先加后用，不是10而是11
这个题目很好地体现了前缀和后缀自增/自减运算符的执行顺序差异：
- 前缀形式(++i)：先进行自增/自减运算，再使用值
- 后缀形式(j--)：先使用值，再进行自增/自减运算知识点：C++、C语言
题友讨论(11)
单选题
C语言
5.
为表示关系x≥y≥z，应使用C语言表达式为（）
A
(x>=y)&(y>=z)
B
(x>=y)AND(y>=z)
C
(x>=y>=z)
D
(x>=y)&&(y>=z)
正确答案：D
官方解析：在C语言中表示关系 x≥y≥z，需要使用正确的逻辑运算符将两个比较表达式连接起来。D选项 (x>=y)&&(y>=z) 是正确答案，因为：
1. && 是C语言中的逻辑与运算符，用于连接两个逻辑表达式
2. x>=y 和 y>=z 分别表示两个比较关系
3. 整体表达式的意思是"x大于等于y"并且"y大于等于z"，正确表达了题目要求的关系
分析其他选项的错误原因：
A错误：(x>=y)&(y>=z) 使用了按位与运算符&，而不是逻辑与运算符&&。按位与是对二进制位进行操作，不适合用来连接逻辑表达式。
B错误：(x>=y)AND(y>=z) 中的AND不是C语言的关键字或运算符，这种写法在C语言中是错误的。
C错误：(x>=y>=z) 这种写法在C语言中是不合法的。虽然在数学表达式中我们经常这样写，但在C语言中必须将比较运算符分开，并用逻辑运算符连接。
因此，要在C语言中正确表示"x大于等于y，且y大于等于z"的关系，应该使用D选项的写法。知识点：C++工程师、2018、C语言
题友讨论(8)
单选题
C语言
6.
在C语言中，以下正确的描述是（ ）。
A
函数的定义可以嵌套，函数的调用不可以嵌套
B
函数的定义不可以嵌套，函数的调用可以嵌套
C
函数的定义和函数的调用均可以嵌套
D
函数的定义和函数的调用均不可以嵌套
正确答案：B
官方解析：在C语言中,函数的定义是不允许嵌套的,即一个函数内部不能再定义另一个函数。但是函数的调用是可以嵌套的,也就是说在一个函数内部可以调用其他函数,而被调用的函数中还可以继续调用其他函数。因此B选项正确。
分析其他选项:
A错误:该选项颠倒了函数定义和调用的嵌套特性。实际上是函数定义不能嵌套,而函数调用可以嵌套。
C错误:函数定义不能嵌套是C语言的基本特征,该选项说函数定义可以嵌套是错误的。
D错误:虽然函数定义确实不能嵌套,但函数调用是可以嵌套的。程序中经常需要在一个函数中调用其他函数,这是很常见的编程需求。
举例说明:
- 函数调用可以嵌套:例如main()函数中调用fun1(),而fun1()中又可以调用fun2()
- 函数定义不能嵌套:不能在fun1()的函数体内再定义一个fun2()函数
这种设计既保证了代码的清晰性,又满足了程序的功能需求。知识点：C语言
题友讨论(11)
单选题
C++
C语言
7.
for(;;) 和 while(1) 的功能是相同的
A
TRUE
B
FALSE
正确答案：A
官方解析：for(;;)和while(1)都是实现无限循环的语法,两者在功能上完全等价。
具体分析:
1. for(;;)是一个for循环的特殊形式:
- 初始化表达式为空
- 循环条件为空(在C/C++中空条件等价于true)
- 迭代表达式为空
这样就构成了一个无限循环
2. while(1)是一个while循环:
- 条件表达式永远为真(非0值)
- 因此也会无限循环
3. 两者在编译后生成的机器码基本相同,执行效率也基本一致
4. 选择使用哪种形式主要取决于:
- 编程习惯
- 代码可读性考虑
- 团队编码规范
因此A选项(TRUE)是正确的,因为这两种语法在实现无限循环的功能上确实是完全等价的。
B选项(FALSE)是错误的,因为它否定了这两种语法的等价性,与实际情况不符。
在实际编程中,这两种写法都是常见的,程序员可以根据具体场景选择使用。知识点：C++、C语言
题友讨论(8)
单选题
C语言
8.
int i, *p = &i;是正确的C声明，请问这句话的说法是正确的吗？
A
正确
B
错误
正确答案：A
官方解析：int i, *p = &i; 这个声明语句在C语言中是完全正确的。这条语句的含义是:定义一个整型变量i,同时定义一个指向整型的指针变量p,并将i的地址赋值给指针p。
具体分析这个声明:
1. int i - 声明一个整型变量i
2. *p - 声明一个指针变量p
3. = &i - 将变量i的地址赋值给指针p
这是C语言中非常常见的指针初始化方式。指针变量p指向变量i的内存地址,通过p可以间接访问和修改i的值。这种声明方式语法正确,符合C语言的语法规则。
因此A选项"正确"是对的。
B选项"错误"显然不对,因为这种声明方式确实是C语言中合法且常用的语法形式。在C语言中,指针是一种重要的数据类型,可以在声明时直接进行初始化,就像这个例子中展示的那样。
所以原题中的说法是正确的,选A。知识点：C语言
题友讨论(22)
单选题
C++
C语言
9.
如果有定义语句 int *ptr[4]，typeid(ptr).name() 结果为 "A4_Pi",
请问对 int *(ptr[4]) ， typeid(ptr).name() 输出是
A
PPi
B
A4_Pi
C
PA4_i
D
A4_i
正确答案：B
官方解析：这道题目考察了C++中数组指针声明和typeid的输出规则。
在第一个声明中，int *ptr[4] 和 int *(ptr[4]) 本质上是相同的声明，它们都表示一个含有4个整型指针的数组。括号的存在并不改变声明的本质含义。
typeid(ptr).name() 输出 "A4_Pi" 的含义是：
- A4 表示大小为4的数组
- Pi 表示指向int的指针(Pointer to int)
因此，对于 int *(ptr[4])，typeid(ptr).name() 的输出仍然是 "A4_Pi"，所以 B 选项是正确答案。
分析其他选项：
A选项 "PPi" 错误：这表示指向指针的指针，与原声明不符
C选项 "PA4_i" 错误：这表示指向大小为4的数组的指针，顺序错误
D选项 "A4_i" 错误：这缺少了指针标识符P，不完整
关键在于理解：加入括号 int *(ptr[4]) 不会改变类型本质，它与 int *ptr[4] 是等价的声明。两种写法的优先级和结合性完全相同，因此会得到相同的 typeid 输出结果。知识点：C++、C++工程师、2017、C语言
题友讨论(9)
单选题
C语言
10.
假定有语句“ int b[10], *pb; ”，则不正确的赋值为 （ ）。
A
pb=b
B
pb=b[5]
C
pb=b+2
D
pb=&b[0]
正确答案：B
官方解析：在C语言中,这道题目考察了数组指针的基本概念和赋值操作的正确性。
B选项 pb=b[5] 是不正确的赋值。因为b[5]表示数组b中下标为5的元素的值,是一个int类型数据,而pb是一个指针变量,不能直接将整型值赋给指针变量。
分析其他选项的正确性:
A选项 pb=b 是正确的。因为数组名b代表数组首元素的地址,可以直接赋值给指针变量pb。
C选项 pb=b+2 也是正确的。b+2表示数组b中第3个元素的地址(偏移量为2),可以赋值给指针变量pb。
D选项 pb=&b[0] 同样正确。&b[0]表示数组b第一个元素的地址,等同于数组名b,可以赋值给指针变量pb。
总结:在指针赋值时,需要赋予的是地址值,而不能是普通的整型数据。B选项试图将一个整型值直接赋给指针变量,这种操作在语法上是错误的。知识点：C语言
题友讨论(13)
单选题
C++
C语言
11.
下列程序的打印结果是?
1
2
3
charp1[15] ="abcd", *p2 ="ABCD", str[50] ="xyz";
strcpy(str + 2,strcat(p1 + 2, p2 + 1));
printf("%s", str);A
xyabcAB
B
abcABz
C
ABabcz
D
xycdBCD
E
运行出错
正确答案：D
官方解析：这道题目考察了C语言中字符串操作函数strcat和strcpy的使用，以及指针运算。让我们逐步分析代码执行过程：
1. 初始状态：
- p1[15] = "abcd"，即p1存储了字符串"abcd"
- p2 = "ABCD"，p2指向字符串常量"ABCD"
- str[50] = "xyz"，str存储了字符串"xyz"
2. 执行strcat(p1 + 2, p2 + 1)：
- p1 + 2 指向"cd"
- p2 + 1 指向"BCD"
- strcat将"BCD"连接到"cd"后面，得到"cdBCD"
3. 执行strcpy(str + 2, ...)：
- str + 2 指向str中的"z"位置
- 将上一步得到的"cdBCD"复制到这个位置
- 最终str变成"xycdBCD"
因此D选项"xycdBCD"是正确答案。
分析其他选项：
A错误："xyabcAB"，这个结果混淆了strcat的操作对象
B错误："abcABz"，这个结果没有考虑到指针偏移的影响
C错误："ABabcz"，这个结果完全理解错了字符串拼接的顺序
关键点：
1. 理解指针偏移运算：p1+2, p2+1, str+2分别指向原字符串的不同位置
2. strcat函数会将第二个参数接到第一个参数的末尾
3. strcpy函数会将源字符串复制到目标位置，覆盖原有内容知识点：C++、C语言
题友讨论(28)
单选题
编译和体系结构
C语言
12.
在32位系统环境，编译选项为4字节对齐，那么sizeof (A)和sizeof (B)是______。
1
2
3
4
5
6
7
8
9
10
11
12
13
structA {
inta;
shortb;
intc;
chard;
};
structB {
inta;
shortb;
chard;
intc;
};
A
16，16
B
13，12
C
16，12
D
11，16
正确答案：C
官方解析：这道题目考察结构体内存对齐的计算规则。在32位系统下采用4字节对齐时，需要遵循以下规则：
1. 每个成员的起始地址必须是其自身大小的整数倍
2. 整个结构体的大小必须是所有成员中最大对齐要求的整数倍
3. 结构体大小也必须是编译选项指定的对齐字节(此处为4字节)的整数倍
对于结构体A：
- int a (4字节)：起始位置0，占用0-3
- short b (2字节)：从4开始，占用4-5，后有2字节填充
- int c (4字节)：从8开始，占用8-11
- char d (1字节)：从12开始，占用12，需要3字节填充以满足4字节对齐
最终sizeof(A) = 16字节
对于结构体B：
- int a (4字节)：起始位置0，占用0-3
- short b (2字节)：从4开始，占用4-5
- char d (1字节)：从6开始，占用6，填充1字节
- int c (4字节)：从8开始，占用8-11，无需填充
最终sizeof(B) = 12字节
所以答案C(16,12)是正确的。
其他选项分析：
A(16,16)错误：B结构体通过成员重排列优化了内存布局，不需要16字节
B(13,12)错误：A结构体需要按4字节对齐，13不是4的整数倍
D(11,16)错误：两个结构体的大小都计算错误知识点：编译和体系结构、C语言
题友讨论(16)
单选题
数组
C++
C语言
13.
已知int a[3][4];则下列能表示a[1][2]元素值的是()
A
*(*(a+1)+2)
B
*(a+1+2)
C
(&a[0]+1)[2]
D
*(a[0]+1)
正确答案：A
官方解析：这道题目考察了二维数组的指针访问方式。让我们逐个分析各个选项：
A选项 *（*（a+1）+2）是正确的,分析过程如下：
1. a+1 得到第2行的首地址
2. *(a+1) 得到第2行首元素地址
3. *(a+1)+2 得到第2行第3个元素的地址
4. *（*（a+1）+2）最终得到a[1][2]的值
其他选项错误原因：
B. *(a+1+2) 错误,因为a+1+2会跳过3个长度为4的一维数组,超出了数组范围
C. (&a[0]+1)[2] 错误,&a[0]取第一行地址,+1后指向第二行,但[2]无法正确访问到目标元素
D. *(a[0]+1) 错误,a[0]表示第一行首元素地址,+1后指向a[0][1],而不是目标元素a[1][2]
要点提示：
二维数组的指针访问需要理解:
1. 数组名a本身是指向第一行的指针
2. 每一行都是一个包含4个元素的一维数组
3. 需要通过两次解引用才能获取具体元素的值知识点：C++、数组、C语言
题友讨论(76)
单选题
C语言
14.
若二维数组a有m列，则在a[i][j]前面的元素个数为 ？
A
j * m + i
B
i * m + j
C
i * m + j - 1
D
i * m + j + 1
正确答案：B
你的答案：C
官方解析：在二维数组中,要计算a[i][j]前面的元素个数,需要:
1) 先计算完整的i行数据的个数: i * m(m为列数)
2) 再加上当前行已经遍历的元素个数: j
所以前面的元素总数为: i * m + j
选项B正确地表达了这个计算公式。逐行计算时,每行有m个元素,共有i个完整行,再加上当前行的j个元素。
分析其他选项:
A错误:j * m + i 颠倒了行列的计算顺序,这样会得到错误的结果
C错误:i * m + j - 1 少计算了一个元素
D错误:i * m + j + 1 多计算了一个元素
举例说明:
若有一个3×4的二维数组,求a[2][1]前面的元素个数:
- 完整的2行: 2 * 4 = 8个元素
- 当前行已遍历: 1个元素
总计: 8 + 1 = 9个元素
验证选项B的公式: 2 * 4 + 1 = 9,结果正确。知识点：C语言
题友讨论(30)
单选题
C语言
15.
下⾯函数的功能是（）
1
2
3
4
5
intfun (char*s) {
char*p = s;
while(*p++);
returnp-s-1;
}
A
计算字符串的位(bit)数
B
复制⼀个字符串
C
求字符串的长度
D
求字符串存放的位置
正确答案：C
官方解析：这道题目考察的是C语言中字符串长度的计算方法。通过分析代码的执行过程,可以确定该函数实现了计算字符串长度的功能。
代码执行过程:
1. char *p=s: 将指针p指向字符串s的起始位置
2. while(*p++): 指针p不断向后移动,直到遇到字符串结束符''
3. return p-s-1: 返回指针p与起始位置s的距离减1,即为字符串的长度
为什么C是正确答案:
该函数通过指针移动来计数,最终返回的p-s-1正好是字符串中的字符个数(不包含结束符''),这就是字符串的长度。
其他选项分析:
A错误:该函数返回的是字符数量,而不是位(bit)数。字符串的位数应该是长度乘以8(假设ASCII编码)。
B错误:该函数没有进行任何字符串复制操作,只是在遍历字符串。
D错误:该函数返回的是字符串的长度,而不是字符串在内存中的存储位置。
这是一个典型的字符串长度计算函数,类似于标准库中的strlen()函数的实现原理。代码简洁高效,利用了指针运算和字符串以''结尾的特性。知识点：iOS工程师、2019、C语言
题友讨论(15)
单选题
C语言
16.
对于代码段
1
2
3
charc = 48;
inti = 1, j = 10;
j = !(c > j)&&i++;则i和j的值分别是1和0。请问这句话是正确的吗？
A
正确
B
错误
正确答案：A
你的答案：B
官方解析：让我们逐步分析这段代码的执行过程:
1. char c = 48; // 字符'0'的ASCII码是48
2. int i = 1, j = 10;
3. j = !(c > j)&&i++;
关键在于第3行的运算过程:
- c > j 判断: 48 > 10 结果为true
- !true 结果为false
- 由于&&是短路运算符,当左操作数为false时,右操作数不会被执行
- 所以i++不会执行,i保持为1
- 最终j被赋值为false对应的整数值0
因此:
- i的值保持为1(因为i++没有被执行)
- j的值变为0(false转换为整数)
所以"i和j的值分别是1和0"这个说法是正确的,A选项为正确答案。
B选项错误,因为该选项认为结果不是1和0,但通过上述分析可知代码执行后确实得到i=1,j=0的结果。这里考察了:
1. 字符和整数的比较
2. 逻辑运算符的短路特性
3. 逻辑值到整数的转换规则
这是一个考察C++基础运算规则和运算符优先级的题目。知识点：C语言
题友讨论(31)
单选题
C++
C语言
17.
若有说明语句：char c = ’\72’;，则变量c（）
A
包含1个字符
B
包含2个字符
C
包含3个字符
D
说明不合法，c的值不确定
正确答案：A
官方解析：在C语言中，字符常量可以用ASCII码的八进制形式表示，即'ddd'格式（d表示0-7的八进制数字）。这里的'72'就是一个八进制ASCII码表示的字符。
'72'是一个八进制数，转换成十进制是58，对应ASCII码表中的字符':'（冒号）。因此变量c中存储的就是一个字符':'，所以c包含1个字符，A选项正确。
分析其他选项：
B错误：字符变量c只能存储单个字符，不可能包含2个字符
C错误：同理，字符变量c不可能包含3个字符
D错误：这种表示方法是完全合法的，c的值是确定的（就是ASCII码值为58的字符）
补充说明：在C语言中，字符常量除了可以直接用字符表示（如'a'），还可以用ASCII码的八进制（以开头）或十六进制（以x开头）形式表示。这种表示方法在处理特殊字符时特别有用。知识点：C++、C语言
题友讨论(17)
单选题
C++
C语言
18.
64位系统下，*p=NULL和*p=new char[100]， sizeof(p)各为多少？
A
4,4
B
4,8
C
8,4
D
8,8
正确答案：D
官方解析：在64位系统中,指针p的大小(sizeof(p))始终是8字节,这是因为在64位系统中指针的寻址空间是64位的,不管指针指向什么类型的数据或是NULL。
具体分析:
1. 当*p=NULL时:
指针p本身的大小是8字节(64位)。因为NULL本质上也是一个地址(空地址),在64位系统中仍然需要8字节来存储。
2. 当*p=new char[100]时:
指针p仍然是8字节,因为p存储的是动态分配的内存块的起始地址。虽然分配了100个字节的空间,但这不影响指针本身的大小。
错误选项分析:
A选项(4,4)错误:在64位系统中指针不可能是4字节
B选项(4,8)错误:同样违背了64位系统指针大小的基本原则
C选项(8,4)错误:指针大小在同一系统中是固定的,不会因指向内容不同而改变
因此D选项(8,8)是正确的,体现了64位系统中指针大小的一致性原则。要注意区分指针本身的大小和指针所指向内存空间的大小是两个不同的概念。知识点：C++、C语言
题友讨论(38)
单选题
C++
C语言
19.
字符串“a+b=20\n”的长度是（）
A
7
B
8
C
5
D
6
正确答案：A
官方解析：字符串"a+b=20 "的长度是7个字符,包括:
1. 字母'a' - 1个字符
2. 加号'+' - 1个字符
3. 字母'b' - 1个字符
4. 等号'=' - 1个字符
5. 数字'2' - 1个字符
6. 数字'0' - 1个字符
7. 换行符' ' - 虽然写作两个字符,但在Java中表示一个转义字符
其他选项分析:
B选项8错误:可能误认为' '占用2个字符长度
C选项5错误:忽略了' '这个字符
D选项6错误:计数不完整,漏掉了某个字符
需要特别注意的是,在Java中转义字符(如 、 、\等)虽然在代码中写作两个字符,但实际上只占用一个字符位置。这是因为反斜杠''和后面的字符共同构成了一个特殊的字符表示。知识点：C++、C语言
题友讨论(47)
单选题
字符串
栈
C语言
20.
设栈的初始状态为空，当字符序列 "a3_" 作为栈的输入时，输出长度为 3 的且可以用作 C 语言标识符的字符串序列有（）个。
A
4
B
6
C
3
D
5
正确答案：C
你的答案：A
官方解析：这道题目考察栈的基本操作和C语言标识符的规则。
关键分析要点：
1. 输入序列为"a3_"，长度为3
2. C语言标识符的规则：只能由字母、数字和下划线组成，且首字母不能是数字
3. 需要通过栈的入栈出栈操作得到所有可能的排列组合
具体分析过程：
1. 对于长度为3的序列，其中包含字符'a'、'3'、'_'
2. C语言标识符首字符不能为数字，所以'3'不能作为开头
3. 通过栈操作可以得到以下合法的标识符：
- a3_
- a_3
- _a3
所以总共有3种合法的标识符序列。
其他选项分析：
A(4)错误：高估了合法序列的数量
B(6)错误：包含了一些非法的序列（如以数字3开头的序列）
D(5)错误：同样高估了合法序列的数量
因此C选项"3"是正确答案，因为只有这3种排列可以作为合法的C语言标识符。知识点：字符串、栈、C语言
题友讨论(96)
单选题
C++
C语言
21.
以下叙述中正确的是（）
A
只能在循环体内和switch语句体内使用break语句
B
当break出现在循环体中的switch语句体内时，其作用是跳出该switch语句体，并中止循环体的执行
C
continue语句的作用是：在执行完本次循环体中剩余语句后，中止循环
D
在while语句和do-while语句中无法使用continue语句
正确答案：A
官方解析：break语句可以用在循环语句和switch语句中,用于跳出当前循环或switch语句块。A选项说法错误,break的使用场景不仅限于循环体和switch语句体内。
分析其他选项:
B选项错误:当break出现在循环体中的switch语句体内时,只能跳出switch语句体,不会中止循环体的执行。
C选项错误:continue语句的作用是立即跳过本次循环的剩余语句,直接进入下一次循环的判断,而不是执行完本次循环体中的剩余语句。
D选项错误:continue语句可以在任何循环结构(for、while、do-while)中使用,用于跳过本次循环中剩余的代码,开始下一次循环。
所以A选项"只能在循环体内和switch语句体内使用break语句"是正确的。break语句的使用确实仅限于这两种场景:
1. 用在循环语句中,用于提前结束循环
2. 用在switch语句中,用于跳出switch结构
这体现了break语句在程序控制流程中的重要作用。知识点：C++、C语言
题友讨论(19)
单选题
C++
C语言
22.
在上下文和头文件均正常的情况下，下面代码的输出结果是()
1
2
3
4
5
6
7
8
9
10
11
12
intmain(){
intpid;
intnum = 1;
pid = fork();
if(pid > 0){
num++;
printf("in parent:num:%d addr:%x\n", num, &num);
}
elseif(pid == 0){
printf("in child:num:%d addr:%x\n", num, &num);
}
}A
父子进程中输出的num相同,num地址不相同
B
父子进程中输出的num不同,num地址相同
C
父子进程中输出的num相同,num地址也相同
D
父子进程中输出的num不同,num地址不相同
正确答案：B
你的答案：D
官方解析：fork()函数调用后会创建一个子进程,子进程是父进程的副本。这道题目主要考察fork()之后父子进程的内存关系。
B选项是正确答案,原因如下:
1. num值不同:fork()执行后,父进程中num会执行num++变为2,而子进程中num保持为1不变
2. 地址相同:子进程会复制父进程的地址空间,所以变量num在父子进程中的虚拟地址是相同的
分析其他选项:
A错误:父子进程中num值一定不同,因为父进程执行了num++
C错误:父子进程中num值不同,所以不可能相同
D错误:虽然num值确实不同,但地址是相同的而不是不同的
更详细的解释:
- fork()创建的子进程会复制父进程的数据段、代码段等
- 虽然是复制,但采用了写时复制(Copy-On-Write)技术
- 父子进程拥有相同的虚拟地址空间,但映射到不同的物理地址
- 当发生写操作时(如父进程中的num++),才会真正复制物理页面
- 这就是为什么地址相同但值可以不同的原因
这也体现了操作系统中进程创建的一个重要优化机制。知识点：C++、C++工程师、运维工程师、前端工程师、算法工程师、PHP工程师、C语言
题友讨论(47)
单选题
C语言
23.
C库函数中malloc依赖下面哪个系统调用增长堆空间（）
A
open
B
ioctl
C
sbrk
D
write
正确答案：C
官方解析：malloc 函数是 C 语言的内存分配函数，它通过调用系统调用 sbrk 来向操作系统申请增加进程的堆空间。sbrk 是 Unix/Linux 系统中用于管理进程堆空间的基本系统调用，它可以通过增加或减少 program break 的位置来调整堆的大小。
分析其他选项：
A. open：这是用于打开文件的系统调用，与内存分配无关。
B. ioctl：这是用于设备控制的系统调用，主要用于对设备进行配置和管理，与内存分配无关。
D. write：这是用于向文件写入数据的系统调用，与内存分配无关。
补充说明：
- malloc 在内部维护了一个内存池，当需要分配内存时，它首先会查看内存池中是否有合适的空闲块。
- 只有当内存池中没有足够的空间时，malloc 才会通过 sbrk 系统调用向操作系统申请更多的堆空间。
- 在现代系统中，malloc 可能还会使用 mmap 系统调用来分配大块内存，但对于扩展堆空间，主要还是依赖 sbrk。知识点：C++工程师、C语言
题友讨论(5)
单选题
C++
C语言
24.
对以下数据结构中data的处理方式描述正确的是()
1
2
3
4
5
structNode
{
intsize;
chardata[0];
};A
data将会被编译成一个char *类型指针
B
全部描述都不正确
C
编译器会认为这就是一个长度为0的数组,而且会支持对于数组data的越界访问
D
编译器会默认将数组data的长度设置为1
正确答案：C
你的答案：B
官方解析：这道题目考察了C语言中零长度数组(zero-length array)的概念。C选项是正确的,因为这种声明方式称为"柔性数组"(Flexible Array Member)。
在C语言中,声明一个长度为0的数组成员是合法的,编译器确实会将其视为长度为0的数组。这种数组可以被越界访问,因为它实际上只是一个占位符,表示在结构体末尾可以存在任意长度的数组。
具体分析其他选项:
A错误:data[0]不会被编译成char*类型指针。它就是一个数组,只是长度为0。虽然使用时可能会像指针一样访问,但本质上仍是数组。
B错误:既然C是正确的,那么"全部描述都不正确"的说法显然不对。
D错误:编译器不会默认将数组长度设置为1。在这种情况下,数组长度确实就是0,这也是柔性数组的特点。
这种结构通常用于实现变长结构体,比如在结构体的末尾存储不定长度的数据。在实际使用时,需要动态分配足够的内存来容纳结构体和后续的数组数据。size成员通常用来记录实际分配的数组长度。这是一种在C语言中实现动态数组的常用技巧。知识点：C++、Java工程师、C++工程师、运维工程师、前端工程师、算法工程师、PHP工程师、C语言
题友讨论(41)
单选题
C语言
25.
阅读如下C代码片段（其中Y表示代码指令地址）：
1
2
3
4
5
6
7
8
9
10
voidoverflow(char* pShellcode,intiLen) {
Y1：charbuffer[8];
Y2:memcpy(buffer, pShellcode, dwLen);
Y3: „„
}
Y4:intmain() {
Y5: „„
Y6: overflow("123456789123456789",18);
Y7: „„
}main主程序调用执行overflow函数后，指令指针指向（）
A
Y3
B
Y7
C
0x34353637
D
0x37363534
正确答案：D
你的答案：B
官方解析：这道题目考察了缓冲区溢出攻击的基本原理和程序执行流程。
代码中存在明显的缓冲区溢出漏洞:buffer数组只有8字节大小,但memcpy函数复制了18字节的数据(字符串"123456789123456789"),这导致了缓冲区溢出。
在缓冲区溢出时:
1. 前8个字节会填充buffer数组空间
2. 后续字节会覆盖栈上的数据,包括:
- 保存的帧指针(EBP)
- 返回地址
由于输入字符串是"123456789123456789",按小端序在内存中存储时,"7654"这四个字符会覆盖返回地址位置。转换为十六进制就是0x37363534,这正是选项D的值。
分析其他选项:
A错误:Y3是overflow函数中的下一条指令,在缓冲区溢出后不会执行到这里
B错误:Y7是main函数中的下一条指令,正常情况下会执行这里,但发生溢出后不会
C错误:0x34353637是"4567"的十六进制表示,但需要考虑小端序存储方式
因此当发生缓冲区溢出后,返回地址被覆盖为0x37363534,这就是程序最终执行的位置。D选项是正确答案。知识点：C++工程师、算法工程师、C语言
题友讨论(9)
单选题
C++
C语言
26.
以下哪个选项是使用select函数检查读超时的正确用法（）
A
if (select(sockfd + 1,&fs,NULL,NULL,&timeout) == 0)
B
if (select(sockfd,NULL,&fs,NULL,&timeout) == 0)
C
if (select(sockfd + 1,NULL,&fs,NULL,&timeout) == 0)
D
if (select(sockfd ,&fs,NULL,NULL,&timeout) == 0)
正确答案：A
你的答案：D
官方解析：select()函数用于监视文件描述符的变化情况,检查读超时需要在第一个参数和第二个参数正确设置。
A选项正确,原因如下:
1. sockfd + 1作为第一个参数是正确的,因为select需要监视的文件描述符范围是[0, sockfd]
2. &fs作为第二个参数(读集合)是正确的,因为要检查读超时
3. 返回值为0表示超时
4. timeout参数正确设置了超时时间
分析其他选项的错误:
B错误:将读集合&fs放在了第三个参数位置(写集合),不能检测读超时
C错误:将读集合&fs放在了第三个参数位置(写集合),不能检测读超时
D错误:第一个参数使用sockfd不正确,应该是sockfd+1,因为select监视的是[0,sockfd]范围内的描述符
select()函数原型为:
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
其中第一个参数nfds指定需要监视的文件描述符数量,取值为最大文件描述符加1。知识点：C++、C++工程师、2017、C语言
题友讨论(35)
多选题
C++
C语言
27.
在C++中，为了建立如图所示的存储结构(即每个结点含两个域,data是数据域,next是指向结点的指针域),则在[] 处应填入选项是
1
2
3
4
5
structlink
{
chardata;
[];
} node;
A
link next;
B
struct link * next;
C
link * next;
D
struct link next;
正确答案：BC
你的答案：C
官方解析：这道题目考察了C语言中链表节点的结构定义。B选项"struct link * next"是正确的,因为:
1. 在链表结构中,next指针需要指向下一个相同类型的节点
2. struct link表示节点的类型
3. *表示这是一个指针
4. next是指针变量的名称
分析其他选项的错误原因:
A. "link next"错误,因为:
- 缺少struct关键字
- 这样定义的是一个同类型的变量而不是指针,无法实现链接功能
C. "link * next"错误,因为:
- 同样缺少struct关键字
- 在C语言中不能省略struct
D. "struct link next"错误,因为:
- 没有指针符号*
- 这样定义的是一个同类型的变量而不是指针,不能用于链接节点
在C语言中定义自引用的结构体时,必须使用完整的"struct 结构体名 *指针名"的形式,这样才能正确表示指向下一个节点的指针。这是实现链表数据结构的基础。知识点：C++、C语言
题友讨论(27)
多选题
C语言
28.
设有以下函数
int f(int a, char * b) {„„}
则下面对函数指针的定义和赋值错误的是（ ）A
int (*p)(int, char*); p=f;
B
int *p(); p=f;
C
int (*)p(); p=&f;
D
int *p(int, char);p=&f;
正确答案：BCD
官方解析：这道题目考察了C语言中函数指针的定义和赋值。其中A选项是正确的函数指针定义和赋值方式，而BCD都是错误的。
让我们逐个分析：
A选项：int (*p)(int, char*); p=f;
这是正确的函数指针定义和赋值。(*p)表明p是一个指针，括号后的(int, char*)表明这是一个接受int和char*类型参数的函数指针，返回值为int。赋值方式也正确。
B选项：int *p(); p=f;
错误原因：这是函数声明而不是函数指针。int *p()声明了一个返回int指针的函数，而不是函数指针。
C选项：int (*)p(); p=&f;
错误原因：语法错误。函数指针声明时，括号中的*号位置不对。正确应该是int (*p)()。
D选项：int *p(int, char); p=&f;
错误原因：这也是函数声明而不是函数指针。声明了一个返回int指针的函数，参数为int和char。
重点注意：
1. 函数指针的定义必须包含(*pointer_name)这样的形式
2. 函数指针定义时参数类型要与指向的函数完全匹配
3. 函数声明和函数指针的定义形式是不同的
4. 赋值时可以使用f或&f，两种方式都是正确的知识点：C语言
题友讨论(17)
多选题
C语言
29.
X定义如下，若存在则a.y[1]的值可能为（）
1
2
3
4
5
X a;
a.x = 0x11223344;unionX{
intx;
chary[4];
};
A
11
B
22
C
33
D
44
正确答案：BC
官方解析：这道题目考察了C语言中联合体(union)的内存共享特性和大小端存储的概念。
在union X中,成员x和数组y共享同一块内存空间。当给x赋值0x11223344时,这个4字节的值会按照系统的大小端方式存储在内存中。
在大多数系统中采用小端存储方式,即:
- 最低字节(44)存储在最低地址 y[0]
- 次低字节(33)存储在次低地址 y[1]
- 次高字节(22)存储在次高地址 y[2]
- 最高字节(11)存储在最高地址 y[3]
因此 a.y[1] 的值为 0x22,即十进制的34(22在十六进制中)。
分析其他选项:
A错误:11是最高位字节,在y[3]中
C错误:33是次低位字节,在y[1]中
D错误:44是最低位字节,在y[0]中
这个结果是基于小端存储方式,如果是大端存储系统,字节顺序会相反,但题目给出的正确答案B说明这里假设的是小端存储系统。知识点：2019、C语言
题友讨论(8)
多选题
C++
C语言
30.
关于指针下列说法正确的是（）
A
任何指针都可以转化为void *
B
void *可以转化为任何指针
C
指针的大小为8个字节
D
指针虽然高效、灵活但可能不安全
正确答案：ABD
你的答案：BC
官方解析：这题主要考察C语言中指针的基本概念和特性。让我们逐个分析正确选项：
A选项正确：任何类型的指针都可以转换为void*。这是因为void*是一个通用指针类型，它可以指向任何类型的数据。这种特性使得void*在需要处理不同类型数据的通用函数中特别有用。
B选项正确：void*可以转换为任何类型的指针。这是void*作为通用指针的另一个重要特性，允许我们在需要时将其转换回特定类型的指针。这种双向转换的特性使得void*在实现多态性时非常有用。
D选项正确：指针确实存在安全隐患。主要问题包括：
- 空指针引用可能导致程序崩溃
- 悬空指针（指向已释放的内存）可能导致不可预知的结果
- 越界访问可能破坏其他数据
- 内存泄漏等问题
C选项错误：指针大小并不是固定的8字节，这与系统架构有关：
- 在32位系统上，指针通常是4字节
- 在64位系统上，指针通常是8字节
所以不能一概而论说指针就是8字节。知识点：C++、C++工程师、2019、C语言
