有如下程序： #include＜iostream＞ using ...

有如下类声明： class XA{ int x； public： XA(int n){x=n；} }； class XB：public XA{ int y； public： XB(int a,int b)； }；在构造函数XB的下列定义中，正确的是( )。

A．XB：：XB(int a，int b)：x(a)，y(b){}
B．XB：：XB(int a，int b)：XA(a)，y(b){}
C．XB：：XB(int a，int b)：x(a)，XB(b){}
D．XB：：XB(int a，int b)iXA(a)，XB(b){}

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public：～BASE(){cout＜＜’’BASE’’；} }； class DERiVED：public BASE{ public：～DERIVED(){tout＜＜’’DERiVED’’；} }； int main(){DERIVED x；return 0；} 执行后的输出结果是( )。

A．BASE
B．DERIVED
C．BASEDERlJVED
D．DERIVEDBASE

单项选择题

有如下类定义： class XX{ int xx； public： XX()：xx(0){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的语句是( )。

A．YY y1(0，0)；
B．YY y2(1)；
C．YY y3(0)；
D．YY y4；

单项选择题

有如下类定义： class XX{ int xdata； public： XX(int n=0)：xdata(n){} }； class YY：public XX{ int ydata； public： YY(int m=0，int n=0)：XX(m)，ydata(n){} }； YY类的对象包含的数据成员的个数是( )。

A．1
B．2
C．3
D．4

单项选择题

下列关于继承方式的描述中，错误的是( )。

A．如果不显式地指定继承方式，缺省的继承方式是私有(private)
B．采用公有继承方式时，基类中的公有成员在派生类中仍是公有成员
C．采用保护继承方式时，基类中的保护成员在派生类中仍然是保护成员
D．采用私有继承方式时，基类中的私有成员在派生类中仍然是私有成员

单项选择题

下列代码段声明了3个类 class Person{}； class Student：public Person{}； class Undergraduate：Student{}；下列关于这些类之间关系的描述中，错误的是( )。

A．类Person是类Undergraduate的基类
B．类Undergraduate从类student公有继承
C．类student是类Person的派生类
D．类Undergraduate是类Person的派生类

单项选择题

下列关于基类和派生类关系的叙述中，正确的是( )。

A．每个类最多只能有一个直接基类
B．派生类中的成员可以访问基类中的任何成员
C．基类的构造函数必须在派生类的构造函数体中调用
D．派生类除了继承基类的成员，还可以定义新的成员

单项选择题

若已定义了类Vehicle，则下列派生类定义中，错误的是( )。

A．class Car：vehicle{／*类体略*／}；
B．class Car：public car{／*类体略*／}
C．class Car：public Vehicle{／*类体略*／)；
D．class Car：virtual Public Vehicle{／*类体略*／)；

单项选择题

下列描述中，错误的是( )。

A．公有继承时基类中的公有成员在派生类中仍是公有成员
B．公有继承时基类中的保护成员在派生类中仍是保护成员
C．保护继承时基类中的公有成员在派生类中仍是公有成员
D．保护继承时基类中的保护成员在派生类中仍是保护成员-

单项选择题

当派生类继承一个基类时，默认的继承方式为( )。

A．Public
B．protected
C．private
D．不确定

单项选择题

下列关于派生类的叙述中，错误的是( )。

A．派生类至少要有一个基类
B．派生类中包括了从基类继承的成员
C．一个派生类可以作为另一个派生类的基类
D．基类成员被派生类继承以后访问权限保持不变

单项选择题

有如下类声明： class MyBASE { int k； public： void set(int n){k=n；} int getoconst{return k；} }； class MyDERIVED：protected MyBASE { protected： int j； public： void set(int m，int n){MyBASE：：set(m)；j=n；} int get()const{return MyBASE：：get()+j；} }；则类MyDERIVED中保护的数据成员和成员函数的个数是( )。

A．4
B．3
C．2
D．1

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Base { public： void fun(){cout＜＜¨Base：：fun’’＜＜endl；} }； class Derived：public Base { public： void fun(){___________ cout＜＜’’Derived：：fun’’＜＜end1； }． }； int main() { Derived d; d．fun()； return 0； } 已知其执行后的输出结果为： Base：：fun Derived：：fun 则程序中下划线处应填入的语句是( )。

A．Base．fun()；
B．Base：：fun()；
C．Base-＞fun()；
D．fun()；

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Base { private： void fun1() const{cout＜＜’’fun1’’；} protected： void fun2() const{cout＜＜’’fun2’’；} public： void fun3() const{cout＜＜’’fun3’’；} }； class Derived：protected Base { public： void fun4()const{cout＜＜’’fun4"；} }； int main() { Derived obj； obj．funl()；／／① obj．fura()；／／② obj．fun3()；／／③ obj．fun4()；／／④ return 0； } 其中有语法错误的语句是( )。

A．①②③④
B．①②⑧
C．②③④
D．①④

单项选择题

在公有继承的情况下，允许派生类直接访问的基类成员包括( )。

A．公有成员
B．公有成员和保护成员
C．公有成员、保护成员和私有成员
D．保护成员

单项选择题

有如下类定义： class MyBase{ int k； public： MyBase(int n=0)：k(n){} int value()const{return k；} }； class MyDerived：MyBase{ intj； public： MyDerived(int i)：j(i){} int getK()const{return k；} int getJ()const{return j；} }; 编译时发现有一处语法错误，对这个错误最准确的描述是( )。

A．函数getK试图访问基类的私有成员变量k
B．在类MyDerived的定义中，基类名MyBase前缺少关键字public、protected或private
C．类MyDerived缺少一个无参的构造函数
D．类MyDerived的构造函数没有对基类数据成员k进行初始化

单项选择题

派生类的成员函数不能访问基类的( )。

A．公有成员和保护成员
B．公有成员
C．私有成员
D．保护成员

单项选择题

若有如下类定义： class B{ void fun1(){} protected： double varl； public： void fun2(){} }； class D：public B{ protected： void fun3(){} }；已知obj是类D的对象，下列句中不违反类成员访问控制权限的是( )。

A．obj．fun1()；
B．obj．var1
C．obj．fun2()；
D．obj．fun3()；

单项选择题

有如下类声明： class Base{ protected； int amount； public； Base(int n=0)：amount(n){} int getAmount()const{return amount；} }； class。Derived：public Base{ protected； int value； public； Derived(int m，int n)：value(m)．Base(n){} Int getData()const{return value+amount；} }；已知x是一个Derived对象，则下列表达式中正确的是( )。

A．x．value+x．getAmount()
B．x．getData()-x．gctAmount()
C．x．getData()．x．amount
D．X．value+x．amount

单项选择题

在一个派生类的成员函数中，试图调用其基类的成员函数"void f()；’’，但无法通过编译。这说明( )。

A．f()是基类的私有成员
B．f()是基类的保护成员
C．派生类的继承方式为私有
D．派生类的继承方式为保护

单项选择题

对于通过公有继承定义的派生类，若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是( )。

A．公有或私有
B．私有
C．保护或私有
D．公有或保护

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE(){cout＜＜’’BASE’’；} }； class DERiVED：public BASE{ public： ～DERIVED(){tout＜＜’’DERiVED’’；} }； int main(){DERIVED x；return 0；} 执行后的输出结果是( )。

你可能感兴趣的试题

有如下类声明： class XA{ int x； public： XA(int n){x=n；} }； class XB：public XA{ int y； public： XB(int a,int b)； }； 在构造函数XB的下列定义中，正确的是( )。

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE(){cout＜＜’’BASE’’；} }； class DERiVED：public BASE{ public： ～DERIVED(){tout＜＜’’DERiVED’’；} }； int main(){DERIVED x；return 0；} 执行后的输出结果是( )。

下列有关继承和派生的叙述中，正确的是( )。

下列有关类继承的叙述中，错误的是( )。

在下列关键字中，不能用来表示继承方式的是( )。

在类声明中，紧跟在“public：”后声明的成员的访问权限是( )。

定义派生类时，若不使用关键字显式地规定采用何种继承方式，则默认方式为( )。

有如下类定义： class XX{ int xdata； public： XX(int n=0)：xdata(n){} }； class YY：public XX{ int ydata； public： YY(int m=0，int n=0)：XX(m)，ydata(n){} }； YY类的对象包含的数据成员的个数是( )。

下列关于继承方式的描述中，错误的是( )。

下列代码段声明了3个类 class Person{}； class Student：public Person{}； class Undergraduate：Student{}； 下列关于这些类之间关系的描述中，错误的是( )。

下列关于基类和派生类关系的叙述中，正确的是( )。

若已定义了类Vehicle，则下列派生类定义中，错误的是( )。

下列描述中，错误的是( )。

当派生类继承一个基类时，默认的继承方式为( )。

下列关于派生类的叙述中，错误的是( )。

在公有继承的情况下，允许派生类直接访问的基类成员包括( )。

派生类的成员函数不能访问基类的( )。

若有如下类定义： class B{ void fun1(){} protected： double varl； public： void fun2(){} }； class D：public B{ protected： void fun3(){} }； 已知obj是类D的对象，下列句中不违反类成员访问控制权限的是( )。

在一个派生类的成员函数中，试图调用其基类的成员函数"void f()；’’，但无法通过编译。这说明( )。

对于通过公有继承定义的派生类，若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是( )。

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public：～BASE(){cout＜＜’’BASE’’；} }； class DERiVED：public BASE{ public：～DERIVED(){tout＜＜’’DERiVED’’；} }； int main(){DERIVED x；return 0；} 执行后的输出结果是( )。

有如下类声明： class XA{ int x； public： XA(int n){x=n；} }； class XB：public XA{ int y； public： XB(int a,int b)； }；在构造函数XB的下列定义中，正确的是( )。

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public：～BASE(){cout＜＜’’BASE’’；} }； class DERiVED：public BASE{ public：～DERIVED(){tout＜＜’’DERiVED’’；} }； int main(){DERIVED x；return 0；} 执行后的输出结果是( )。

下列代码段声明了3个类 class Person{}； class Student：public Person{}； class Undergraduate：Student{}；下列关于这些类之间关系的描述中，错误的是( )。

若有如下类定义： class B{ void fun1(){} protected： double varl； public： void fun2(){} }； class D：public B{ protected： void fun3(){} }；已知obj是类D的对象，下列句中不违反类成员访问控制权限的是( )。