试卷01：
 

单选题

C++

1.

在C++中,一个程序无论由多少个源程序文件组成,其中有且仅有一个主函数main().说法是否正确？

A

正确

B

错误

正确答案：A

官方解析：

在C++程序设计中,一个完整的程序确实有且仅有一个main函数作为程序的入口点,这是C++语言的基本规则之一。

具体原因如下:
1. main函数是程序的唯一入口点,它标志着程序执行的开始。
2. 当程序启动时,操作系统会自动调用main函数。
3. 即使程序由多个源文件(.cpp文件)组成,在链接时也只能有一个main函数。
4. 如果程序中包含多个main函数,在链接时会产生链接错误。

补充说明:
- 虽然一个项目可以包含多个源文件,但这些源文件最终会被编译和链接成一个可执行程序。
- 不同的源文件可以包含不同的函数定义,但main函数必须是唯一的。
- 在大型项目中,可以通过创建多个可执行程序(每个都有自己的main函数)来实现不同的功能模块。

因此A选项"正确"是对的,这条规则是C++程序设计的基本要求。B选项"错误"不符合C++语言的基本规范。

知识点：C++

题友讨论(1) 

单选题

C++

2.

C++ 某基类有构造函数 A()，析构函数 ~A()，其派生类B的构造函数和析构函数分别为 B() 和 ~B()，那么对于派生类 B 的构造和析构，下列说法正确的是 （）

A

构造时，先调用 A()，再调用 B()，析构时，先调用 ~A()，再调用 ~B()

B

构造时，先调用 A()，再调用 B()，析构时，先调用 ~B()，再调用 ~A()

C

构造时，先调用 B()，再调用 A()，析构时，先调用 ~A()，再调用 ~B()

D

构造时，先调用 B()，再调用 A()，析构时，先调用 ~B()，再调用 ~A()

正确答案：B

你的答案：A

官方解析：

在 C++ 中,派生类的构造和析构过程遵循特定的顺序规则。B 选项正确描述了这个过程:构造时从基类到派生类,析构时从派生类到基类。

具体分析:
1. 构造顺序:首先执行基类 A 的构造函数 A(),然后执行派生类 B 的构造函数 B()。这是因为派生类对象包含基类部分,必须先构造基类部分才能确保派生类的正确初始化。

2. 析构顺序:与构造顺序相反,先执行派生类 B 的析构函数 ~B(),再执行基类 A 的析构函数 ~A()。这种顺序确保了派生类资源先被释放,然后再释放基类资源,避免资源泄露。

其他选项错误原因:
A错误:析构顺序颠倒。若先调用基类析构函数,会导致派生类还未完全清理就失去基类支持。

C错误:构造顺序错误(先派生后基类)且析构顺序错误(先基类后派生)。这样会导致派生类构造时缺少基类支持,析构时基类过早释放。

D错误:构造顺序错误。虽然析构顺序正确,但构造时必须先有基类才能构造派生类。

这种构造和析构的顺序安排是 C++ 面向对象特性的重要体现,保证了对象生命周期管理的安全性和可靠性。

知识点：C++、Java工程师、C++工程师、iOS工程师、安卓工程师、运维工程师、前端工程师、算法工程师、测试工程师、2019

题友讨论(7) 

单选题

C++

C语言

3.

若x=2，y=3则x&y的结果是（）

A

0

B

2

C

3

D

5

正确答案：B

官方解析：

这道题目考察位运算符 & (按位与)的运算规则。

在二进制层面上,当 x=2, y=3 时:
2 的二进制表示是: 0010
3 的二进制表示是: 0011

按位与(&)运算规则是:两个位都为1时结果为1,否则为0。
所以 2&3 的运算过程是:
0010
0011
----
0010 = 2(十进制)

因此 x&y 的结果是 2,选项 B 正确。

分析其他选项:
A(0)错误:按位与运算不可能得到0,因为原始数都大于0且有重叠的1位
C(3)错误:结果会小于等于较小的操作数
D(5)错误:按位与的结果一定小于等于参与运算的任何一个数

这是一个典型的位运算考察,要求考生能够将十进制数转换为二进制,并正确应用按位与运算规则。

知识点：C++、C语言

题友讨论(8) 

单选题

C++

4.

关于函数的描述正确的是___。

A

虚函数是一个static型的函数

B

派生类的虚函数与基类的虚函数具有不同的参数个数和类型

C

虚函数是一个非成员函数

D

基类中说明了虚函数后，派生类中起对应的函数可以不必说明为虚函数​

正确答案：D

你的答案：B

官方解析：

这道题目考察了虚函数的基本概念和特性。D选项正确,因为一旦在基类中声明了虚函数,该函数在派生类中自动成为虚函数,不需要再显式声明virtual关键字。这是C++的语言特性,目的是为了简化代码编写并保持继承关系的一致性。

分析其他选项的错误原因:

A错误:虚函数不能是static函数。static成员函数属于类而不属于对象,而虚函数是基于对象的动态绑定机制,两者性质冲突。

B错误:派生类中的虚函数必须与基类的虚函数具有相同的参数个数和类型(返回值可以是协变的)。这是保证多态正确实现的必要条件。

C错误:虚函数必须是类的成员函数。非成员函数无法实现动态绑定,因为它们不属于任何类的作用域。

补充说明:虚函数是C++实现多态的核心机制,它允许在运行时根据对象的实际类型来调用相应的函数实现。基类声明虚函数后,所有继承该函数的派生类函数都自动成为虚函数,这种设计简化了代码编写并确保了继承体系的一致性。

知识点：C++

题友讨论(7) 

单选题

C++

5.

在类Time中的析构函数可以声明为：void ~Time(int) 。

A

正确

B

错误

正确答案：B

你的答案：A

官方解析：

析构函数的声明必须严格遵循固定的语法规则。声明"void ~Time(int)"是错误的,原因如下:

1. 析构函数的声明语法要求:
- 析构函数名必须与类名相同,前面加上波浪号(~)
- 不能有返回值类型(包括void)
- 不能带任何参数
- 每个类只能有一个析构函数

2. 正确的析构函数声明应该是:
~Time()

3. "void ~Time(int)"的错误之处:
- 错误地声明了void返回类型
- 错误地添加了int参数

析构函数的作用是在对象被销毁时进行清理工作,它会自动被调用,不需要人为传递参数。声明为带参数的形式违背了析构函数的设计初衷。

因此B选项"错误"是正确答案,因为这种声明方式违反了C++语言中析构函数的基本语法规则。

知识点：C++

题友讨论(11) 

单选题

C++

6.

对类成员访问权限的控制，是通过设置成员的访问控制属性实现的，下列不是访问控制属性的是(    )
 

A

公有类型

B

私有类型

C

保护类型

D

友元类型

正确答案：D

你的答案：B

官方解析：

在C++中，访问控制属性是用来控制类成员访问权限的关键字。D选项"友元类型"不是一个访问控制属性，而是一种特殊的访问许可机制，所以是正确答案。

分析所有选项：

A. 公有类型(public) - 是标准的访问控制属性，允许任何代码访问该成员
B. 私有类型(private) - 是标准的访问控制属性，只允许类内部访问该成员
C. 保护类型(protected) - 是标准的访问控制属性，允许类内部和子类访问该成员
D. 友元类型(friend) - 不是访问控制属性，而是一种声明机制，用于授予其他类或函数访问私有成员的权限

C++中的访问控制属性只有三种：public、private和protected。friend是一个关键字，用于声明友元关系，它允许被声明为友元的函数或类访问当前类的私有成员，但本身并不是一个访问控制属性。

友元机制是C++特有的一种打破封装的方式，它是对访问控制的补充，而不是访问控制属性本身。因此D选项是正确答案。

知识点：C++

题友讨论(7) 

单选题

C++

7.

有以下程序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream> using namespace std; _______________________ void One(float one){cout<<"1"<<endl;    } void Two(float two){ cout<<"2"<<endl; } void Three(float three){ cout<<"3"<<endl; } void main(){      float i=1,j=2,k=3;     function = One;     function(i);     function= Two;     function(j);     function = Three;     function(k); }

请为横线处选择合适的程序使得程序的运行结果是123   （      ）?

A

void *function();

B

void *function(float);

C

void (*function)();

D

void (*function)(float);

正确答案：D

官方解析：

这道题考察了C++中函数指针的声明和使用。D选项 void (*function)(float) 是正确的答案,因为:

1. 这是一个正确的函数指针声明语法,表示function是一个指向返回值为void、参数为float类型的函数的指针
2. 与程序中One、Two、Three三个函数的签名完全匹配(它们都是返回void,接受一个float参数)
3. 可以通过赋值操作(function = One等)将函数地址赋给这个函数指针
4. 可以像调用普通函数一样使用函数指针(function(i)等)

分析其他选项:
A选项 void *function() - 这是声明了一个返回void指针的函数,而不是函数指针
B选项 void *function(float) - 这是声明了一个带float参数且返回void指针的函数,而不是函数指针
C选项 void (*function)() - 这是声明了一个指向无参数函数的函数指针,与题目中需要传入float参数不匹配

要点提示:
1. 函数指针声明时,*号和标识符必须用括号括起来,否则就变成了函数声明
2. 函数指针的参数列表必须与要指向的函数的参数列表完全匹配

知识点：C++、运维工程师、2019

题友讨论(7) 

单选题

C++

8.

若执行下面的程序时，从键盘上输入 5 ，则输出是（）

1 2 3 4 5 6 7 8 9 10 11 12

int main(int argc, char** argv) {     int x;     scanf("%d",&x);     if(x++ > 5)         printf("%d\n",x);     else         printf("%d\n",x--);     return 0; }

A

7

B

4

C

6

D

5

正确答案：C

官方解析：

这道题目考察了C语言中后缀运算符和程序执行流程的理解。

当输入x=5时,程序执行过程如下:
1. x先参与条件判断表达式 x++ > 5
2. 由于后缀++是在使用x的值之后才进行自增,所以判断时使用的是x的原值5
3. 5 > 5 为false,所以执行else分支
4. else分支中printf("%d ",x--)语句先使用x的值(此时x已经是6,因为前面x++已经生效),然后再执行x--
5. 所以最终输出6

因此C选项6是正确答案。

分析其他选项:
A选项7错误:x在整个过程中最大值为6,不可能输出7
B选项4错误:x的值经过x++后变为6,不可能输出4
D选项5错误:x在输出时已经变为6,不可能输出原值5

这个题目的关键是要理解:
1. 后缀++和--运算符的执行时机
2. 程序语句的执行顺序
3. 变量值的实时变化过程

知识点：C++

题友讨论(7) 

单选题

C++

9.

采用函数重载的目的在于

A

实现共享

B

节约空间

C

提高速度

D

使用方便，提高可靠性

正确答案：D

官方解析：

函数重载是一种允许在同一个类中定义多个名称相同但参数列表不同的函数的机制。D选项是正确的,因为函数重载的主要目的是为了提供更友好的使用方式,让程序员可以用同一个函数名处理不同类型或数量的参数,从而提高代码的可读性和可维护性。

分析其他选项：

A错误："实现共享"不是函数重载的主要目的。函数重载虽然可以复用函数名,但每个重载的函数都是独立的实现,并不存在代码共享。

B错误："节约空间"也不是函数重载的目的。实际上,每个重载的函数都需要独立的内存空间来存储其代码,可能会增加而不是节约空间。

C错误："提高速度"同样不是函数重载的目的。函数重载在编译时就已确定调用哪个版本的函数,不会影响运行时的性能。

重载的真正价值在于通过同一个函数名提供多个不同参数版本的实现,使接口更简单直观,让调用者可以选择最适合自己需求的版本,这提高了代码的可用性和可靠性。比如:print()函数可以重载成print(int x)、print(String s)等多个版本,使用起来更加方便灵活。

知识点：C++

题友讨论(11) 

单选题

C++

C语言

10.

下面程序的输出结果是（）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include<iostream> using namespace std; class ClassA {     friend long fun (ClassA a) {         if (a.i < 2) return 1;         return a.i * fun(ClassA(a.i-1));     } public:     ClassA(long a) { i = a; } private:     long i; }; int main() {     int sum = 0;     for (int i = 0; i < 4; i++) {         sum += fun(ClassA(i));     }     cout << sum; }

 

A

10

B

12

C

16

D

34

正确答案：A

官方解析：

这道题目考察了C++中的递归函数和类的使用。让我们逐步分析代码的执行过程。

程序中定义了一个ClassA类,包含一个friend函数fun。fun函数是一个递归函数,它的功能类似于阶乘运算:当参数小于2时返回1,否则返回当前值乘以(当前值-1)的递归结果。

主函数中进行循环,i从0到3,每次都用i创建ClassA对象并调用fun函数,然后将结果累加到sum中。让我们计算每次循环的结果:

当i=0时: fun(ClassA(0)) = 1
当i=1时: fun(ClassA(1)) = 1
当i=2时: fun(ClassA(2)) = 2 * fun(ClassA(1)) = 2 * 1 = 2
当i=3时: fun(ClassA(3)) = 3 * fun(ClassA(2)) = 3 * 2 = 6

最终sum = 1 + 1 + 2 + 6 = 10

所以A选项10是正确答案。

分析其他选项:
B(12)错误:可能是忽略了i=0和i=1时的特殊情况处理
C(16)错误:可能是错误地认为每个数都进行了完整的阶乘计算
D(34)错误:计算过程完全偏离,没有正确理解递归函数的执行逻辑

这道题目的关键是要理解递归函数的执行过程,以及当参数小于2时的特殊处理。

知识点：C++、C++工程师、2019、C语言

题友讨论(14) 

单选题

C++

11.

下列程序的输出结果为：

1 2 3 4 5 6 7 8 9

#include <stdio.h> #include <string.h> void main() {     char* a[] = {"hello", "the", "world"};     char** pa = a;     pa++;     printf("%s\n", *pa); }

 

A

theworld

B

the

C

hello

D

hellotheword

正确答案：B

官方解析：

这道题目考察的是C++中字符串数组和指针的基本概念。

代码中声明了一个字符串数组 a，包含三个字符串元素："hello"、"the"、"world"。然后用字符串指针 pa 指向数组 a 的首地址。执行 pa++ 操作后，pa 向后移动一个位置，指向了数组的第二个元素，即"the"。最后输出 *pa，就是输出指针 pa 指向的字符串。

因此选择B是正确的,输出结果为"the"。

分析其他选项:
A错误:"theworld"是将第二个和第三个字符串连在一起,但程序中并没有字符串连接操作。

C错误:"hello"是数组的第一个元素,在pa++后已经不再指向这个位置。

D错误:"hellotheword"是将所有字符串连接,但程序中没有这样的操作,而且拼写也不正确(word被写成了word)。

关键点在于理解:
1. 字符串数组的存储方式
2. 字符串指针的移动操作
3. 指针解引用操作的含义

知识点：C++

题友讨论(19) 

单选题

C++

12.

（C++部分）下列关于对象初始化的叙述中，正确的是:

A

定义对象的时候不能对对象进行初始化

B

定义对象之后可以显式地调用构造函数进行初始化

C

定义对象时将自动调用构造函数进行初始化

D

在一个类中必须显式地定义构造函数实现初始化

正确答案：C

官方解析：

C++对象初始化的规则中,定义对象时会自动调用构造函数进行初始化,这是面向对象编程中的一个重要特性。这个过程是由编译器自动完成的,不需要程序员显式调用。

分析各选项:

A错误:C++允许在定义对象时进行初始化,可以使用多种方式,如直接初始化、复制初始化等。

B错误:构造函数只能在对象创建时被调用,对象定义之后不能再显式调用构造函数。如果需要重新初始化对象,应该使用赋值操作或其他成员函数。

C正确:这是C++的基本特性。当创建对象时,编译器会自动调用相应的构造函数来完成对象的初始化工作。这个过程是强制的,不需要也不能由程序员手动触发。

D错误:类可以不显式定义构造函数。如果没有定义任何构造函数,编译器会自动生成一个默认构造函数。默认构造函数可以完成基本的初始化工作。

理解这一点对于正确使用C++面向对象特性非常重要,它确保了对象在使用前都处于有效状态。

知识点：C++

题友讨论(13) 

单选题

C++

13.

一个全局变量tally,两个线程并发执行(代码段都是ThreadProc),问两个线程都结束后,tally取值范围为_______

1 2 3 4 5

int tally=0;//全局变量   void ThreadProc(){      for(int i=1;i<=50;i++)           tally+=1; }

A

[50,100]

B

[100.100]

C

[1275,2550]

D

[2550,2550]

正确答案：A

官方解析：

这道题目考察了多线程并发执行时共享变量的访问问题。A选项[50,100]是正确的,因为:

1. 每个线程执行的ThreadProc函数都会循环50次,每次将tally加1
2. 由于两个线程并发执行,且对共享变量tally的操作(tally+=1)不是原子操作,会产生竞态条件
3. 在最理想的情况下,两个线程完全串行执行,最终结果为100
4. 在最糟糕的情况下,由于竞态条件,两个线程的自增操作可能完全重叠,最终结果可能只有50
5. 因此最终tally的取值范围是[50,100]

分析其他选项:
B错误:[100,100]表示tally一定等于100,这忽略了并发竞态导致的结果不确定性
C错误:[1275,2550]和D错误:[2550,2550]给出的数值范围明显过大,与两个线程各执行50次加1操作不符

这个问题也说明了在多线程编程中,如果需要确保共享变量操作的原子性,应该使用互斥锁(mutex)或原子操作来保护临界区,避免数据竞争带来的不确定性。

知识点：C++

题友讨论(36) 

单选题

Java

C++

14.

对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑（ ）

A

参数个数

B

参数类型

C

返回值类型

D

参数顺序

正确答案：C

官方解析：

在判断方法重载(Overload)时,返回值类型确实不是考虑因素。方法重载的判定只需要关注方法名称和参数列表。

具体分析:
1. 参数个数(A选项)是判断方法重载的重要依据。同名方法如果参数个数不同,就构成重载。例如:
void test()
void test(int a)

2. 参数类型(B选项)也是判断方法重载的关键。同名方法的参数类型不同也构成重载。例如:
void test(int a)
void test(String s)

3. 返回值类型(C选项)不是判断方法重载的依据。两个方法如果只有返回值类型不同,其他都相同,这不构成重载,反而会导致编译错误。例如:
int test(int a)
void test(int a) //编译错误

4. 参数顺序(D选项)同样是判断方法重载的依据。参数类型的顺序不同也可以构成重载。例如:
void test(int a, String s)
void test(String s, int a)

所以C是正确答案,因为返回值类型对方法重载的判定没有影响,而其他选项都是方法重载判定时需要考虑的要素。

知识点：C++、Java

题友讨论(75) 

单选题

C++

C语言

15.

x*=y+8等价于x=x*(y+8)。请问这句话是正确的吗？

A

正确

B

错误

正确答案：A

官方解析：

x*=y+8 确实等价于 x=x*(y+8)。这涉及到编程语言中复合赋值运算符的基本规则。

让我们通过分析来理解:
1. *=是一个复合赋值运算符,它将乘法和赋值操作结合在一起
2. 复合赋值运算符的计算规则是:先计算右边表达式的值,然后与左边变量进行运算,最后将结果赋值给左边变量
3. 在这个例子中:
- y+8会先计算出一个值
- 然后用x乘以这个值
- 最终结果赋值给x

这个转换关系在所有编程语言中都是成立的,因此A选项"正确"是对的。

实际编程中这两种写法的最终结果是完全相同的,只是使用复合赋值运算符(x*=y+8)的写法更简洁。需要注意的是,操作的优先级在这里很重要,y+8是作为一个整体参与乘法运算的。

知识点：C++、C语言

题友讨论(7) 

单选题

C++

16.

使用pthread库的多线程程序编译时需要加什么连接参数?

A

-lpthread

B

-fthis-is-varialble

C

fcond-mismatch

D

-MMD

正确答案：A

官方解析：

在使用pthread库进行多线程编程时,需要使用-lpthread参数来链接pthread线程库。这是因为:

1. pthread库不是Linux系统默认加载的标准库,需要在编译时显式指定链接。

2. -l参数是gcc/g++编译器的链接选项,用于指定需要链接的库。pthread是具体的库名,合起来就是-lpthread。

3. 如果不加这个链接参数,虽然代码可以编译通过,但在链接时会报"undefined reference"的错误,因为找不到pthread相关的函数实现。

分析其他选项:

B: -fthis-is-varialble 是一个虚构的参数,在gcc中并不存在这个编译选项。

C: fcond-mismatch 同样是不存在的编译选项。

D: -MMD 是gcc的预处理参数,用于生成依赖文件,与线程库的链接无关。

在实际开发中,-lpthread是多线程程序最基本的编译要求。编译命令通常是:
gcc -o program program.c -lpthread
或
g++ -o program program.cpp -lpthread

知识点：C++

题友讨论(15) 

单选题

C++

C语言

17.

函数作用：将整型数组p中n个数据增大

1 2 3 4 5 6 7 8 9 10

void increment_ints (int p [ ], int n) {   assert(p != NULL);  /* 确保p不为空指针 */   assert(n >= 0);  /* 确保n不为负数 */   while (n)  /* 循环n次. */   {     *p++;          /* 增大p*/     p++, n--;      /* p指向下一位，n减1 */   } }

以上代码的实现有错误，下面哪句话的表述是正确的？

A

*p++应该改为(*p)++

B

数组的值是一个不能改变的值，所以p不能直接被修改。应该使用一个和p相关联的指针来完成这个操作。

C

while循环的条件必须是一个布尔类型的表达式，表达式应该为n!=0.

D

p不应该定义为变长的数组，参数中不应该包含参数n。

正确答案：A

你的答案：B

官方解析：

这道题目考察了C语言中指针运算和自增运算符的优先级理解。A选项是正确的,因为在原代码中*p++存在优先级问题。

在C语言中,后缀运算符++的优先级高于解引用运算符*,所以*p++相当于*(p++),这会导致先执行p++,再解引用p。这样的操作顺序与函数的目标(增大数组中的值)不符。正确的写法应该是(*p)++,用括号明确优先级,使得先解引用p获取数组元素的值,再对该值进行自增操作。

分析其他选项:
B错误:数组名可以作为指针使用,p是函数参数,可以在函数内部修改p的值,这不会影响原数组。

C错误:while(n)是完全合法的C语言表达式,当n为0时表示false,非0时表示true,不必强制写成n!=0。

D错误:数组作为函数参数时传递的是指针,需要额外的参数n来指定数组长度,这是C语言的常见用法。参数n的存在是必要的。

正确实现应该是:
1. 使用(*p)++来增大数组元素的值
2. 然后移动指针p并减少计数器n
这样才能正确完成给数组所有元素加1的功能。

知识点：C++、C语言

题友讨论(105) 

单选题

C++

C语言

18.

1 2 3 4 5 6 7 8 9 10 11

void GetMemory(char **p, int num) {     *p = (char *)malloc(num); } void Test(void) {     char *str = NULL;     GetMemory(&str, 100);     strcpy(str, "hello");     printf("%s", str); }

请问运行Test 函数会有什么样的结果？

A

hello

B

空

C

出错

正确答案：A

你的答案：未作答

官方解析：

这段代码能够正确执行并输出"hello"。让我们来分析代码的执行过程：

1. 在 Test 函数中，首先声明了一个字符指针 str 并初始化为 NULL。

2. 调用 GetMemory 函数时，传入 str 的地址（&str）和大小 100。GetMemory 函数通过二级指针操作，为 str 分配了 100 字节的内存空间。这里的关键是通过二级指针可以修改原始指针的值。

3. malloc 函数成功分配内存后，str 就指向了这块有效的内存空间。

4. 接着使用 strcpy 函数将字符串"hello"复制到新分配的内存空间中。

5. 最后 printf 函数打印出存储在 str 指向的内存空间中的字符串，即"hello"。

分析其他选项：
B选项错误：不会输出空字符串，因为内存分配成功后已经复制了"hello"字符串。

C选项错误：代码不会出错，因为：
- GetMemory 函数正确使用二级指针修改了原始指针的值
- malloc 成功分配了内存
- strcpy 操作的是有效的内存空间
- 内存空间足够容纳"hello"字符串

所以这段代码是完全合法且可以正确执行的，会输出"hello"。

知识点：C++、C语言

题友讨论(35) 

单选题

C++

19.

假定一个类的构造函数为A(int aa,int bb){a=aa--;b=a*bb;}，则执行A x(4,5);语句后，a和b的值分别为（）

A

20和5

B

3和15

C

5和4

D

4和20

正确答案：D

你的答案：B

官方解析：

要搞清楚这道题目,关键是理解构造函数中的赋值顺序和后缀自减运算符--的特点。

让我们逐步分析构造函数 A(int aa,int bb){a=aa--;b=a*bb;}:

1. 首先执行 A x(4,5) 时,参数 aa=4, bb=5

2. 在构造函数中:
- 先执行 a=aa--
- aa-- 是后缀自减,意味着先使用aa的值(4)进行赋值,然后aa再减1
- 所以 a=4

3. 接着执行 b=a*bb
- 此时 a=4, bb=5
- 所以 b=4*5=20

4. 最终结果:
- a的值为4
- b的值为20

因此D选项(4和20)是正确答案。

分析其他选项错误原因:
A(20和5)错误:把b的计算结果误认为是a的值
B(3和15)错误:错误地认为aa--会立即影响a的值
C(5和4)错误:完全理解错误赋值过程和计算顺序

这道题目的关键是要理解后缀自减运算符的执行时机,以及赋值语句的执行顺序。

知识点：C++

题友讨论(0) 

单选题

C++

C语言

20.

关于结构类型下面说法错误的是（）
 

A

结构类型不可作为其成员的类型

B

结构变量的大小就是其各成员的大小之和

C

结构类型可以定义在函数之外

D

结构类型可以定义在函数之中

正确答案：B

你的答案：A

官方解析：

这道题目考察了C语言中结构体的基本概念。B选项错误,因为结构变量的大小并不简单等于各成员大小之和,还需要考虑内存对齐。由于内存对齐的存在,结构体的总大小通常会大于等于各成员大小之和。

分析其他选项:
A正确:结构类型不能作为其成员的类型,因为这会导致无限递归定义,编译器无法确定结构体的大小。但结构体可以包含指向自身类型的指针成员。

C正确:结构类型可以定义在函数外部,这是全局结构类型定义的常见方式,可以被多个函数共同使用。

D正确:结构类型也可以定义在函数内部,这种情况下该结构类型的作用域仅限于函数内部。

此题主要是考察对结构体内存布局的理解,特别是内存对齐这一重要概念。内存对齐是为了提高内存访问效率,虽然会造成一定的内存浪费,但这是一种必要的性能优化手段。

知识点：C++、C语言

题友讨论(33) 

单选题

C++

C语言

21.

若有以下定义和声明：

1 2 3 4 5 6 7

struct student {     char num[6];     char name[8];     float mark[4]; } a[30]; FILE *fp;

设文件中以二进制形式存有10个班的学生数据，且已正确打开，文件指针定位于文

件开头。若要从文件中读出30个学生的数据放入a数组中，以下能实现此功能的语句

是（）

A

for (i=0;i<30;i++) fread (&a[i],sizeof(struct student),1L,fp);

B

for (i=0;i<30;i++) fread (&a[i],sizeof(struct student),30L,fp);

C

fread (a,sizeof(struct student),L,fp);

D

for (i=0;i<30;i++) fread(a[i],sizeof(struct student),1L,fp);

正确答案：A

官方解析：

这道题目考察了C语言文件操作中fread函数的使用。A选项是正确的,因为它正确实现了从文件中逐个读取30个学生数据的功能。

let's分析每个选项:

A正确:
- fread(&a[i], sizeof(struct student), 1L, fp)表示每次读取1个student结构体大小的数据
- 通过循环30次,依次将数据读入数组a的每个元素中
- 参数设置正确:目标地址&a[i]、单个数据大小sizeof(struct student)、读取数量1L、文件指针fp

B错误:
- fread的第三个参数设为30L,表示每次要读取30个结构体
- 这会导致每次循环都试图读取30个数据,造成数据重复读取和越界

C错误:
- 参数L未定义,会导致编译错误
- 即使改为30L也缺少了必要的取地址符号&

D错误:
- a[i]前缺少取地址符号&
- 直接使用a[i]作为目标地址是错误的,因为需要的是地址而不是值

补充说明:
fread函数的标准格式是:
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
其中ptr是存储数据的地址,size是每个数据项的大小,nmemb是要读取的数据项数量。

知识点：C++、C语言

题友讨论(10) 

单选题

C++

22.

在c++中，以下能对二维数组 a 进行正确初始化的语句是（）

A

int a[2][]={{1,0,1},{5,2,3}};

B

int a[][]={{1,2,3},{4,5,6}};

C

int a[2][4]={1,2,3},{4,5},{6}};

D

int a[][3]={{1,0,1},{},{1,1}};

正确答案：D

官方解析：

在C++中进行二维数组初始化时需要遵循一些规则。D选项是正确的,因为在声明二维数组时,第一个维度可以省略,但第二个维度必须明确指定。D选项中 int a[][3] 明确指定了列数为3,且初始化值符合语法规则。空的花括号 {} 表示该行所有元素都初始化为0。

分析其他选项的错误原因：

A错误：int a[2][] 是不合法的声明方式。在C++中声明二维数组时不能省略第二个维度。

B错误：int a[][] 的声明方式在C++中是非法的,必须至少指定第二个维度。

C错误：初始化列表的语法错误。正确的语法应该是用逗号分隔每个子数组,且每个子数组都要用花括号括起来。

具体解释D选项：
int a[][3]={{1,0,1},{},{1,1}}; 表示：
- 第一行是 {1,0,1}
- 第二行是 {} 即 {0,0,0}
- 第三行是 {1,1,0} (最后一个元素自动补0)
- 由于提供了3个子数组,所以第一维的大小自动确定为3

这种初始化方式完全符合C++语法规范。

知识点：C++

题友讨论(47) 

单选题

C++

C语言

23.

设有说明int s[2]={0,1},*p=s; 则下列错误的C语句是 （       ）。

A

s+=1;

B

p+=1;

C

*p++;

D

(*p)++;

正确答案：A

官方解析：

题目中涉及数组和指针的基础知识。A选项是错误的,因为在C语言中数组名s代表数组首地址,是常量,不能进行自增运算(s+=1)。

分析其他选项：
B选项(p+=1)正确：p是指向数组的指针变量,可以进行指针运算,p+=1会使指针向后移动一个整型数据的长度。

C选项(*p++)正确：这是一个后缀自增运算,先使用*p的值,然后p指针向后移动一个位置。等价于*(p++)。

D选项((*p)++)正确：这是将p指向的值进行自增运算,由于使用了括号,会先进行解引用操作,然后对该值进行自增。

总结：
此题的关键在于理解数组名是常量指针,而指针变量可以进行各种合法的指针运算。数组名s作为常量指针,不能进行s+=1这样的运算,但是指向数组的指针变量p是可以进行算术运算的。其他三个选项都是合法的指针或数值运算操作。

知识点：C++、C语言

题友讨论(24) 

单选题

C++

C语言

24.

下面选项中关于位运算的叙述正确的是（）

A

位运算的对象只能是整型或字符型数据

B

位运算符都需要两个操作数

C

左移运算的结果总是原操作数据2倍

D

右移运算时，高位总是补0

正确答案：A

官方解析：

位运算是计算机中一种基本的运算类型。A选项正确,因为位运算只能作用于整型(byte、short、int、long)和字符型(char)数据,不能用于浮点型数据。这是因为位运算直接操作二进制位,而浮点数的存储结构比较特殊。

分析其他选项:

B错误:并非所有位运算符都需要两个操作数。比如取反运算符(~)就是一元运算符,只需要一个操作数。

C错误:左移运算不一定使结果变为原来的2倍。左移1位确实相当于乘以2,但如果移位导致1溢出到高位之外,结果就不是2倍关系了。

D错误:右移运算时,对于有符号数,如果原数为正数则高位补0,如果原数为负数则高位补1。只有无符号右移(>>>)才是无论何时高位都补0。

这个题目考察了位运算的基本知识点,包括运算对象类型、运算符操作数要求、移位运算的特点等。理解这些特性对于进行底层编程和位操作非常重要。

知识点：C++、C语言

题友讨论(41) 

单选题

C++

25.

对于某个函数调用，可以不给出被调用函数的原形的情况是（）。

A

被调用函数式无参函数

B

被调用函数式无返回值的函数

C

函数的定义在调用处之前

D

函数的定义在别的程序文件中

正确答案：C

官方解析：

在C语言中,当函数的定义在调用处之前时,编译器已经知道了函数的完整信息(包括返回类型、参数列表等),因此可以不用显式地声明函数原型。这就解释了为什么C是正确答案。

分析其他选项:

A错误:即使是无参函数,如果函数定义在调用处之后,仍然需要提供函数原型。因为编译器需要知道这个函数是否真的不需要参数。

B错误:无返回值的函数(void函数)同样需要原型声明(如果定义在调用后),编译器需要知道该函数不返回值,以便正确处理函数调用。

D错误:如果函数定义在其他源文件中,恰恰更需要在调用处提供函数原型。因为编译器在编译当前文件时无法看到其他文件中的函数定义。

补充说明:
函数原型的主要作用是让编译器提前知道函数的签名信息,包括:
- 返回值类型
- 参数个数和类型
- 调用约定

只有当函数定义在调用之前时,由于编译器已经获得了完整的函数信息,才可以省略函数原型声明。

知识点：C++

题友讨论(12) 

单选题

C++

C语言

26.

能够从输入流中提取指定长度的字节序列的函数是（）

A

get

B

getline

C

read

D

cin

正确答案：C

官方解析：

read()函数是专门用于从输入流中读取指定长度字节的函数。它可以精确控制要读取的字节数,并将读取到的字节存储到指定的缓冲区中。

分析各选项:
C选项正确: read()函数的主要功能就是从输入流中读取指定数量的字节。它有以下特点:
- 可以指定要读取的具体字节数
- 返回实际读取到的字节数
- 可以指定存储读取数据的缓冲区

A选项错误: get()函数通常用于读取单个字符,不能指定读取长度。

B选项错误: getline()函数主要用于读取一行字符串,直到遇到换行符,不能指定具体的字节长度。

D选项错误: cin是C++的标准输入流对象,本身不是函数,而是通过重载运算符>>来实现输入,不能直接指定读取长度。

补充说明:read()函数的典型用法如:
stream.read(buffer, length)
其中buffer是存储数据的缓冲区,length是要读取的字节数。这种精确控制读取长度的能力使它特别适合处理二进制数据。

知识点：C++、C语言

题友讨论(6) 

单选题

C++

27.

以下代码执行结果是（）

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 30

#include <iostream> using namespace std; class Parent { public:     virtual void output(); }; void Parent::output() {     printf("Parent!"); } class Son : public Parent { public:     virtual void output(); }; void Son::output() {     printf("Son!"); } int main() {     Son s;     memset(&s, 0, sizeof(s));     Parent& p = s;     p.output();     return 0; }

A

Parent!

B

Son!

C

编译出错

D

没有输出结果，程序运行出错

正确答案：D

官方解析：

这道题考察了C++中虚函数表(vtable)的原理以及内存操作对对象状态的影响。

当使用memset将整个对象清零时,会破坏对象的vtable指针。在C++中,包含虚函数的类会在对象内存布局的开头包含一个指向虚函数表的指针。这个指针对于虚函数的调用至关重要。

程序执行过程分析:
1. 创建son类对象s
2. memset操作将s对象的所有内存清零,包括vtable指针
3. 通过父类引用p指向s
4. 调用p.output()时,由于vtable指针已被清零,程序会试图访问地址0处的虚函数表
5. 访问空指针会导致程序崩溃

所以D选项"没有输出结果，程序运行出错"是正确的。

其他选项分析:
A错误:不会输出"parent!",因为程序在尝试调用虚函数前就会崩溃
B错误:不会输出"son!",原因同上
C错误:不会输出"son!parent!",原因同上

这个例子说明了在C++中直接操作对象的底层内存是危险的,特别是对含有虚函数的对象。应该使用proper的构造函数和赋值操作符来操作对象,而不是直接修改内存。

知识点：C++

题友讨论(51) 

多选题

C++

28.

下列关于运算符优先级的描述中，错误的是（）。

A

所有运算符结合性是从左到右

B

优先级顺序可以被括号改变

C

位运算符优先级比右移运算符优先级高

D

结合方向决定同一优先级的运算符的运算次序

正确答案：AC

你的答案：AD

官方解析：

大多数运算符结合性是从左到右，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符，A选项错误。用括号改变优先级顺序，使得括号内的运算优先于括号外的运算，B正确。右移运算符比位运算符优先级高，C错误。同一优先级的运算符，运算次序由结合方向所决定，D正确。

知识点：C++

题友讨论(0) 

多选题

C++

C语言

29.

数组定义如下：

1	int arr[2] = {10, 20};

下列函数的作用是，将数组中的两个数值进行交换，即调用函数后，arr变为{20,10}，

1 2 3

voidchange(int* p) { /*……*/ }

若要正确实现函数功能，/*……*/为（）

A

int temp = p[0];
p[0] = p[1];
p[1] = temp;

B

p[0] = p[0] ^ p[1]; p[1] = p[1] ^ p[0]; p[0] = p[0] ^ p[1];

C

int n1 = p[0];
int n2 = p[1];
int temp = n1;
n1 = n2;
n2 = temp;

D

int temp = *p;
*p = *(p+1);
*(p+1) = temp;

正确答案：ABD

你的答案：ABCD

官方解析：

这道题目考察了在C语言中通过指针实现数组元素交换的基本操作。ABD都是正确的实现方式，它们采用了不同的语法形式但实现了相同的功能。

选项A使用数组下标方式访问元素：p[0]和p[1]分别代表数组的第一个和第二个元素，通过临时变量temp完成交换，这是最直观的实现方式。

选项B使用异或运算来实现交换，但这里有一个索引错误：应该是p[0]和p[1]而不是p[1]和p[2]。如果将索引修正，这种方法也是可行的。这种实现方式的特点是不需要额外的临时变量。

选项C是错误的，因为它只是在局部变量n1和n2之间进行了交换，并没有修改原数组的值。函数结束后，这些局部变量会被销毁，原数组内容不会改变。

选项D使用指针算术运算来访问数组元素：*p表示第一个元素，*(p+1)表示第二个元素。这种方法本质上与A方法相同，只是换成了指针的形式来访问数组元素。

总之，要实现数组元素交换，关键是要真实修改到原数组的内容，而不是仅在局部变量间进行交换。A、B(需修正索引)、D三种方法都直接操作了原数组的内存空间，因此都能实现预期功能。

知识点：C++、C++工程师、2019、C语言

题友讨论(39) 

多选题

C++

30.

有以下程序,程序的功能是菜单选择：选择A输出：ADD；选择D输出：DELETE ；选择S输出：SORT；选择Q则退出。

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

#include <iostream> using namespace std; int main() {     char choice = ' ';     while (________)     {         cout << "Menu: A(dd) D(elete) S(ort) Q(uit),Select one:";         cin >> choice;         if (choice == 'A')         {             cout << "ADD" << endl;             continue;         }         else if (choice == 'D')         {             cout << "DELETE " << endl;             continue;         }         else if (choice == 'S')         {             cout << "SORT" << endl;             continue;         }         else if (choice == 'Q')             break;     } }

请为横线处选择合适的程序（      ）

A

choice!='Q'

B

choice!=Q

C

choice

D

1

正确答案：AD

官方解析：

在给定的程序中，横线处需要填写循环条件。程序要求：选择Q时退出循环，其他情况继续循环。分析选项：

1. A. choice!='Q'

   • 初始时choice为空格（' '），不等于'Q'，条件为真，进入循环。
   • 输入A/D/S后，choice不等于'Q'，循环继续。
   • 输入Q时，在循环体内执行break跳出循环，功能正确 ✅

2. B. choice!=Q

   • Q未加单引号，视为变量名，但未定义，编译错误 ❌

3. C. choice

   • choice为字符类型，非\0时条件为真（如'Q'的 ASCII 值为 81，非零）。
   • 输入Q后，虽然执行break，但下一次循环条件仍为真（choice='Q'），会再次进入循环，无法退出 ❌

4. D. 1

   • 恒真条件，循环持续执行。
   • 输入Q时通过break跳出循环，功能正确 ✅

错误分析

• 选项B存在语法错误，排除。
• 选项C在输入Q后无法终止循环，不符合要求。

知识点：C++、Java工程师、C++工程师、iOS工程师、安卓工程师、运维工程师、算法工程师、测试工程师、2019、系统工程师、测试开发工程师