国家二级C++机试(继承和派生)模拟试卷8(题后含答案及解析)
国家二级C++机试（继承和派生）模拟试卷8 (题后含答案及解析)
题型有：1. 选择题
选择题
1． 有如下类定义： class AA{ int a： public： AA(intn=0)：a(n){} }； class BB：public AA{ public： BB(int n)____ }；
其中横线处缺失部分是( )。
A．：a(n）{}
B．：AA(n）{}
C．{a(n）；}
D．{a=n；}
正确答案：B
解析：根据派生类构造函数的一般格式：＜派生类名＞（＜总参数表＞）：＜基类名1＞（＜参数表1＞），…＜基类名n＞＜参数表n＞），＜成员对象名1＞（＜参数表n+1＞），＜成员对象名m＞（＜参数表n+m＞）＜派生类构造函数体＞。在派生类BB的构造函数总参数表后面应该接上基类名AA和其参数。
知识模块：继承和派生
2． 有如下程序： #inc1ude ＜iostream＞ using namespace std；
class Basel{ public： Basel(int d) {cout＜＜d；} ～Basel( ){} }；
class Base2{ public： Base2(int d) {cout＜＜d；} ～Base2( ){} }； class Derived： public Basel， Base2{ public：
Derived (int a，int b，int c，int d)； Basel(b)， Base2(a)， bl(d)， b2(c) {}
Private： int b1； int b2； }； int main( ){ Derived d(1，2，3，4)； retum 0； } 运行时的输出结果是( )。
A．1234
B．2134
C．12
D．21
正确答案：D
解析：程序在创建派生类对象d时，分别调用基类Basel和Basel的构造函数。 知识模块：继承和派生
3． 已知基类Employee只有一个构造函数，其定义如下： Employee：：Employee(int n)：id(n){} Manager是Employee的派生类，则下列对Manager的构造函数的定义中，正确的是( )。
A．Manager：：Manager(intn）：id(n）{}
B．Manager：：Manager(int n）{id=n；}
C．Manager：：Manager(int n）： Employee(n）{}
D．Manager：：Manager(int n）{Employee(n）；}
正确答案：C
解析：基类的构造函数是带有参数的，派生类从基类派生，这就需要在派生类的构造函数名后面显示的调用基类的构造函数。 知识模块：继承和派生
4． 有如下程序： #inc1ude ＜iostream＞ using namespace std；
class A{ public： A( ){cout＜＜’A’；} ～A( ){cout＜＜’C’；} }； class B：public A{ public： B( ){cout＜＜’G’；} ～B( ){cout＜＜’T’；} }； int main( ){ B obj；
return 0； } 运行这个程序的输出结果是( )。
A．GATC
B．AGTC
C．GACT
D．AGCT
正确答案：B
解析：派生类B是由基类A公开继承而来，所以在创建类B的obj对象时，首先执行基类A的构造函数A( )，输出A，再执行派生类B的构造函数B( )，输出G，当程序结束时，首先执行派生类的析构函数～B( )，输出T，再执行基类A的析构函数—A( )，输出C。 知识模块：继承和派生
5． 有如下程序： #inc1ude＜iostream＞ using namespace std；
class Base{ public： void fun( ) {cout＜’B’；} }； class Derived：public Base{ public： void fun( ){______cout＜＜’D’；} }；
int main( ){ Derived d； d．fun( )； return 0； } 若程序的输出结果是BD，则划线处缺失的部分是( )。
A．Fun( )；
B．Base．fun( )；
C．Base：：fun( )；
D．Base一＞fun( )；
正确答案：C
解析：派生类Derived的对象d调用其成员函数fun0，要输出结果为BD，所以在其成员函数fun0中要调用基类Base的成员函数fun0。 知识模块：继承和派生
6． 下列关于虚基类的描述中，错误的是( )。
A．使用虚基类可以消除由多继承产生的二义性
B．构造派生类对象时，虚基类的构造函数只被调用一次
C．声明“class B：virtual publicA”说明类B为虚基类
D．建立派生类对象时，首先调用虚基类的构造函数
正确答案：C
解析：虚基类是为了消除由多重继承产生的二义性而提出的。虚基类的说明格式是：Class＜类名＞：virtual＜继承方式＞＜基类名＞，其中关键字virtual与继承方式的位置无关，但必须位于基类名之前，且virtual只对紧随其后基类名起作用。对于本题来说，声明“classB：virtual public A”说明类A为虚基类。
知识模块：继承和派生
7． 有如下程序： #inc1ude＜iostream＞ using namespace std；
class Mountain{ int height； public： Mountain (int h=0)： height(h){}
virtual char* GetName( ) const{return”山”；} int GetHeight( ) const{return
height；} }； class Lushan：public Mountain{ Public： Lushan(int d)：Mountain(d){} Char*GetName( ) const{return”庐山”；} }； int
main( ){ Mountain *p=new Lushan(1000)； cout＜＜p一＞GetName( )＜＜”海拔”＜＜p一＞GetHeight( )＜＜”米”； return 0； } 运行这个程序的输出结果是( )。
A．庐山海拔1000米
B．庐山海拔0米
C．山海拔1000米
D．山海拔0米
正确答案：A
解析：在基类Mountain中定义了虚函数GetName( )输出字符串“山”，而在派生类Lushan中对虚函数GetName( )进行了重新定义，输出字符串“庐山”。在主函数中对派生类中的虚函数GetName( )进行了多态调用，此时调用的是派生类中重新定义的GetName( )，输出字符字符串“庐山”。 知识模块：继承和派生
8． 在C++中，用于实现运行时多态性的是( )。
A．内联函数
B．重载函数
C．模板函数
D．虚函数
正确答案：D
解析：此题考查的是虚函数的概念。C++语言的多态性有两种：函数重载和虚函数。虚函数只有在运行时才能被确定，称为运行时多态。编译时的多态是通过函数重载和模板实现的。 知识模块：继承和派生
9． 下列关于虚函数的说明中，正确的是( )。
A．从虚基类继承的函数都是虚函数
B．虚函数不得是静态成员函数
C．只能通过指针或引用调用虚函数
D．抽象类中的成员函数都是虚函数
正确答案：B
解析：此题考查的是虚函数的概念。在成员函数的声明前面加上virual关键字，即可把函数声明为虚函数。虚函数可以是另一个函数的友元函数而不能是静态成员函数。 知识模块：继承和派生
10． 有如下程序： #inc1ude ＜iostream＞ using namespace std；
class Base { public： void funl( ){cout＜＜”Base\n”；} virtual
void fun2( ){cout＜＜”Base\n”；} }； class Derived： public Base
{ public： void funl( ){cout＜＜”Derived\n”；} void fun2( ){cout＜＜”Derived\n”；} }； void f(Base&b){b．funl( )； b．fun2( )；} int
main( ) { Derived obj； f(obj)； return 0； } 执行这个程序的输出结果是( )。
A．Base
B．Base Base Derived
C．Derived
D．Derived Base Derived
正确答案：B
解析：此题考查的是虚函数的概念。在C++语言中，一个派生类的对象可以被它的任何一个基类的指针所指向，若基类和派生类中存在一模一样的成员函数。那么通过该基类指针调用这样的成员函数时，若这个成员函数被定义成虚函数，那么就调用派生类中的；否则就调用基类中的。本题中，在f( )函数中，形参b是一个基类的引用，它引用的是主函数中定义的派生类对象obj，所以在调用funl0时，运行的是基类的版本，而fun2( )运行的是派生类的版本。 知识模块：继承和派生
11． 有如下程序 #inc1ude ＜iostream＞ using namespace std；
class A{ public： virtual void func1( ){cout＜”A1”；} void
func2( ){ cout＜＜”A2”；} }； class B：public A{ public： void
func1( ){cout＜”B1”；} void func2( ){cout＜”‘B2”；} }； int
main( ){ A *p=new B； p一＞func1( )； p一＞func2( )；
return 0： } 运行此程序，屏幕上将显示输出( )。
A．BIB2
B．AIA2
C．BIA2
D．AIB2
正确答案：C
解析：此题考查的是虚函数的概念。此题中，funcl是虚函数，func2是一般成员函数，而且在派生类与基类中都存在两个这样的函数。在主函数中，语句A*p=new B；定义了一个基类的指针p，并让它指向一个派生类对象。所以通过该指针调用funcl时，运行的是派生类的版本，而通过该指针调用func2运行的是基类的版本。所以程序运行的最后输出是：B1A2。 知识模块：继承和派生
国家二级(C++)机试模拟试卷26(题后含答案及解析)_0
国家二级（C++）机试模拟试卷26 (题后含答案及解析)
题型有：1. 程序改错题 2. 简单应用题 3. 综合应用题
程序改错题（30分）
使用VC6打开考生文件夹下的工程RevPrroj7。此工程包含一个源程序文件
RevMain7.cpp。在该文件中，函数fun( )的功能是：逐个比较a、b两个字符串对应位置中的字符，把ASCII码值大或相等的字符依次存放到c数组中，形成一个新的字符串。例如：若a中的字符串为aBCDeFgH，b中的字符串为ABcd，则c中的字符串为 aBcdeFgH。 请改正程序中的错误，使它能得到正确结果。
注意，不要改动主函数，不得删行或增行，也不得更改程序的结构。 源程序文件RevMain7.cpp中的程序清单如下： //RevMain7.cpp #include＜iostream＞ #include＜string＞ using namespace std； void fun(char *p，char *q，char *c) { int k=1； while(*p!=*q) { if(*p＜*q) c[k]=*q；
else c[k]=*p； if(*p) p++； if(*q) q++； } } int main( )
{ char a[10]=“aBCDeFgH”，b[10]=“ABcd”，c[80]={‘\0’}； fun(a，b，c)； cout＜＜”The string a is “＜＜a＜＜’\n’； cout＜＜”The string b is
“＜＜b＜＜’\n’； cout＜＜”The string c is “＜＜c＜＜endl； return
0； }
正确答案：
国家二级(C++)机试模拟试卷6(题后含答案及解析)_0
国家二级（C++）机试模拟试卷6 (题后含答案及解析)
题型有：1. 程序改错题 2. 简单应用题 3. 综合应用题
程序改错题（30分）
1． 使用VC6打开考生文件夹下的工程test7_1，此工程包含一个源程序文件test7_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下： Constructor1 Constructor1 Constructor1 Destructor
Constructor2 Destructor x=0 x=5 Destructor Destructor 源程序文件test1_1.cpp清单如下： #include＜iostream.h＞ class B
{int X; public：B( ){X=0;cout＜＜”Constructorl”＜＜endl;}B(int
i){x=i;cout＜＜”Constructor2”＜＜endl;}～B( ){cout＜＜”Destructor”＜＜endl;}
／**********found*********／～B(int i){cout＜＜i＜＜”be Destructor”＜＜endl;}void print( ){cout＜＜”x=“＜＜x＜＜endl;} }; void
main( ) {B *ptr;ptr=new B[2]; ／**********found*********／ptr[0]=B(0);ptr[1]=B(5); ／**********found********／for(int i=0; i＜2;)
ptr[i].print( );delete []ptr; }
正确答案：(1)错误：～B(int i){cout＜＜”be Destructor”＜＜endl;} 正确：应将其删除(2)错误：ptr[0]=B(0); 正确：ptr[0]=B( );(3)错误：for(int=0;i＜2;) 正确：for(int i=0;i＜2;i++)
国家二级(C++)机试模拟试卷2(题后含答案及解析)_0
国家二级（C++）机试模拟试卷2 (题后含答案及解析)
题型有：1. 程序改错题 2. 简单应用题 3. 综合应用题
程序改错题（30分）
1． 使用VC6打开考生文件夹下的工程test3_1，此工程包含一个源程序文件test3_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下： A:a=5 display1:a=6 display2:a=5 源程序文件test3_1.cpp清单如下：
#include＜iostream.h＞ Class A { public: ／**********found**********／ A ( ){} void printa( ){cout＜＜”A:a=“＜＜a＜＜endl;} private： int a; ／***********found**********／ class B; }; class B { public:
／*********found**********／ void display1(A t) { (*t).a++；cout＜＜”display1:a=“＜＜(*t).a＜＜endl； } void display2(A t)
{ t.a--;cout＜＜”display2:a=“＜＜t.a＜＜end1; } }; void
main( ) { A obj1; B obj2; obj1.printa( );
obj2.display1(&obj1); obj2.display2(obi1); }
正确答案：(1)错误：A( ){} 正确：A( ){a=5；}(2)错误：class B；
国家二级(C++)机试模拟试卷134(题后含答案及解析)
国家二级（C++）机试模拟试卷134 (题后含答案及解析)
题型有：1. 选择题 2. 基本操作题 3. 简单应用题 4. 综合应用题
选择题
1． 下列数据结构中，属于非线性结构的是( )。
A．循环队列
B．带链队列
C．二叉树
D．带链栈
正确答案：C
解析：树是简单的非线性结构，所以二叉树作为树的一种也是一种非线性结构。
2． 下列数据结构中，能够按照“先进后出”原则存取数据的是( )。
A．循环队列
B．栈
C．队列
D．二叉树
正确答案：B
解析：栈是按先进后出的原则组织数据的。队列是先进先出的原则组织数据。
3． 对于循环队列，下列叙述中正确的是( )。
A．队头指针是固定不变的
B．队头指针一定大于队尾指针
C．队头指针一定小于队尾指针
D．队头指针可以大于队尾指针，也可以小于队尾指针
正确答案：D
解析：循环队列的队头指针与队尾指针都不是固定的，随着入队与出队操作要进行变化。因为是循环利用的队列结构所以队头指针有时可能大于队尾指针有时也可能小于队尾指针。
4． 算法的空间复杂度是指( )。
A．算法在执行过程中所需要的计算机存储空间
B．算法所处理的数据量
C．算法程序中的语句或指令条数
D．算法在执行过程中所需要的临时工作单元数
正确答案：A
解析：算法的空间复杂度是指算法在执行过程中所需要的内存空间。所以选择A。
5． 软件设计中划分模块的一个准则是( )。
A．低内聚低耦合
B．高内聚低耦合
C．低内聚高耦合
D．高内聚高耦合
正确答案：B
解析：一般较优秀的软件设计，应尽量做到高内聚，低耦合，即减弱模块之间的耦合性和提高模块内的内聚性，有利于提高模块的独立性。
6． 下列选项中不属于结构化程序设计原则的是( )。
A．可封装
B．自顶向下
C．模块化
D．逐步求精
正确答案：A
解析：结构化程序设计的思想包括：自顶向下、逐步求精、模块化、限制使用goto语句，所以选择A。
国家二级C++机试(继承和派生)模拟试卷17(题后含答案及解析)
国家二级C++机试（继承和派生）模拟试卷17 (题后含答案及解析)
题型有：1. 选择题
选择题
1． 已知基类Emp1oyee只有一个构造函数，其定义如下：
Emp1oyee::Emp1oyee(int n):id(n){} Manager是Emp1oyee的派生类，则下列对Manager的构造函数的定义中，正确的是( )。
A．Manager::Manager(int n):id(n){}
B．Manager::Manager(int n){id=n;}
C．Manager::Manager(int n): Emp1oyee(n){}
D．Manager::Manager(int n){Emp1oyee(n);}
正确答案：C
解析：基类的构造函数是带有参数的，派生类从基类派生，这就需要在派生类的构造函数名后面显示的调用基类的构造函数。 知识模块：继承和派生
2． 有如下程序： #incLude ＜iostream＞ using namespace std;
c1ass A{ public: A( ){cout＜”A’;} ～A( ){cout＜＜’C’；} }；
c1ass B:public A{ public: BO{cout＜＜’G’;} ～BO{couK＜’T’；} }； int main0{ B obj; return 0; } 运行这个程序的输出结果是( )。
A．GATC
B．AGTC
C．GACT
D．AGCT
正确答案：B
解析：派生类B是由基类A公开继承而来，所以在创建类B的obj对象时，首先执行基类A的构造函数A( )，输出A，再执行派生类B的构造函数BO，输出G，当程序结束时，首先执行派生类的析构函数～BO，输出T，再执行基类A的析构函数～A( )，输出C。 知识模块：继承和派生
国家二级(C++)机试模拟试卷11(题后含答案及解析)_0
国家二级（C++）机试模拟试卷11 (题后含答案及解析)
题型有：1. 程序改错题 2. 简单应用题 3. 综合应用题
程序改错题（30分）
1． 使用VC6打开考生文件夹下的工程test12_1，此工程包含一个源程序文件test_12.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果如下： fun (Sample &p) 1 2 fun (Sample *p) 3 4 20 10 源程序文件test12_1清单如下： #include＜iostream .h＞ class Sample
{ private： int x，y； static int z； public： Sample(int a，int b){ x=a；y=b； } void fun(Sample &p)； void fun(Sample *p)；
static void print(Sample s)； }； /*************** found ***************/
int z=10； void Sample：：fun(Sample &p) { x=p.K；y=p.y； cout＜＜”fun(Sample &p)”＜＜” “＜＜x＜＜” “＜＜y＜＜endl； } void Sample：：fun(Sample *p) { /************** found **************/ x=p.x；
y=p.y； cout＜＜”fun(Sample *p) “＜＜” ‘＜＜x＜＜” “＜＜y＜＜endl； }
void Sample：：print (Sample s) { /*************** found
国家二级C++机试(继承和派生)模拟试卷4(题后含答案及解析)
国家二级C++机试（继承和派生）模拟试卷4 (题后含答案及解析)
题型有：1. 选择题
选择题
1． 有如下程序：#include＜iostream＞using namespace std；class
BASE{public：～BASE( ){cout＜＜”BASE”；}}；class DERIVED：public
BASE{public：～DERIVED( ){cout＜＜”DERIVED”；}}；int
main( ){DERIVE
D．x；return 0；}执行后的输出结果是( )。
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：此题考查的是派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。 知识模块：继承和派生
2． 在下列关键字中，不能用来表示继承方式的是( )。
A．private
B．static
C．public
D．protected
正确答案：B
解析：此题考查的是继承方式。继承方式有私有(private)、保护(protected)、公有(public)三种。 知识模块：继承和派生
3． 有如下类定义：class XX{int xx；public：xx( )：xx(O){cout＜＜’A’；}XX(int n)：xx(n){cout＜＜’B’；}}；class YY：public XX{int yy；public：YY( )：yy(0){cout＜＜yy；}YY(int n)：XX(n+1)，yy(n){cout＜＜yy；}YY(int
m，int n)：XX(m)，yy(n){cout＜＜yy；}}；下列选项中，输出结果为A0的语句是( )。
国家二级(JAVA)机试模拟试卷8(题后含答案及解析)
国家二级（JAVA）机试模拟试卷8 (题后含答案及解析)
题型有：1. 选择题 2. 基本操作题 3. 简单应用题 4. 综合应用题
选择题
1． Java程序的并发机制是( )。
A．多线程
B．多接口
C．多平台
D．多态性
正确答案：A
解析：Java是通过多线程实现并发机制的。多线程是指一个程序中包含多个执行流， 多线程程序设计的含义是可以将程序任务分成几个并行的子任务。
2． 将E-R图转换为关系模式时，实体和联系都可以表示为( )。
A．属性
B．键
C．关系
D．域
正确答案：C
解析：将E-R图转换为关系模式时，实体和联系都可以表示为关系。
3． 下列方法中，不属于类String的方法是( )。
A．toLowerCase( )
B．valueOf( )
C．charAt( )
D．append( )
正确答案：D
解析：String的方法中，toLowerCase( )方法是转换成小写，valueof( )方法是获得相 应数值，charAt( )方法是提取字符串中指定位置的字符。append( )是StringBuffer的方法。
4． grid[9][5]描述的是( )。
A．二维数组
B．一维数组
C．五维数组
D．九维数组
正确答案：A
解析：这是一个二维数组，[]中的数字是每一维的大小。
5． 下列运算符中，优先级最高的是( )。
A．++
B．+
C．*
D．>
正确答案：A
解析：在这些运算符中++运算符优先级最高。
6． 下面叙述中错误的是（ ）。
A．软件测试的目的是发现错误并改正错误
B．对被调试的程序进行“错误定位”是程序调试的必要步骤
C．程序调试通常也被称为Debug
D．软件测试应严格执行测试计划，排除测试的随意性
正确答案：A
解析：软件测试的目的是为了发现错误及漏洞而执行程序的过程。软件测试要严格执行测试计划。程序调式通常也称Debug ，对被调试的程序进行“错误”定位是程序调试的必要步骤。
国家二级C++机试(继承和派生)模拟试卷7(题后含答案及解析)
国家二级C++机试（继承和派生）模拟试卷7 (题后含答案及解析)
题型有：1. 选择题
选择题
1． 对于通过公有继承定义的派生类，若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是( )。
A．公有或私有
B．私有
C．保护或私有
D．公有或保护
正确答案：D
解析：通过公有继承定义的派生类，其成员函数可以访问基类的公有成员和保护成员，但不能访问基类的私有成员。 知识模块：继承和派生
2． 建立一个有成员对象的派生类对象时，各构造函数体的执行次序为( )。
A．派生类、成员对象类、基类
B．成员对象类、基类、派生类
C．基类、成员对象类、派生类
D．基类、派生类、成员对象类
正确答案：C
解析：建立派生类对象的时候，构造函数的执行顺序如下：执行基类的构造函数，调用的顺序按照基类被继承时候的顺序（自左向右）。然后是执行成员对象的构造函数，调用顺序按照各个成员对象在类中的声明顺序（自上而下），最后是执行派生类的构造函数。 知识模块：继承和派生
3． 有如下类定义和变量定义： class Parents{ public： int
publicData； prlVate： mt privateData； }； class ChildA：public
Parents{／*类体略*／}； class ChildB：private Parents{／*类体略*／)；
ChildA a： ChildB b： 下列语句中正确的是( )。
A．cout＜＜a．publicData＜＜endl；
B．cout＜＜a．priVateData＜＜endl；
C．cout＜＜b．publicData＜＜endl；
D．cout＜＜b．priVateData＜＜endl；
正确答案：A
解析：基类Parents的私有成员privateData在派生类ChildA和ChildB中是不可以访问，所以选项B、D是错误，而派生类ChildB私有继承基类Parents，所以基类Parents的公有成员publicData在派生类ChildB中变为私有成员，只能
国家二级C++机试(基本操作题)模拟试卷2(题后含答案及解析)
国家二级C++机试（基本操作题）模拟试卷2 (题后含答案及解析)
题型有：1.
1． 使用VC6打开考生文件夹proj1下的工程proj1，其中有“沙发”类Sofa和主函数main的定义。程序中位于每个／／ERROR
**********found**********下的语句行有错误，请加以更正。更正后程序的输出应该是： 座位数：3 颜色：红色 注意：只能修改每个／／ERROR，**********found**********下的那一行，不要改动程序中的其他内容。#include＜iost：ream＞using namespace st：d；class Sofa{ ／／“沙发”类 int seats；
／／座位数 char color[10]；／／颜色public： ／／ERROR******found****** Sofa(int s,const char * co){ ／／ERROR******found****** if(CO＝NULL) color[0]＝’＼0’； else
strcpy(color，co)； } ／／ERROR******found****** const char *
getSeats( )const{return seats；) const char * gel：Color( )const{return
color；)}；int：main( ){ Sofa sara(3)； cout：＜＜“座位数：”＜＜sara．getSeats( )＜＜end1； cout：＜＜“颜色：”＜＜sara．getColor( )＜＜end1； return 0；}
正确答案：(1)Sofa(int s，const char * co＝“红色”)：seats(s){ (2)if(co＝＝NULL) (3)int getSeats( )const{return seats；}