有如下两个类定义 class xx{ private： d...

单项选择题

建立一个有成员对象的派生类对象时，各构造函数体的执行次序为( )。

A．派生类、成员对象类、基类
B．成员对象类、基类、派生类
C．基类、成员对象类、派生类
D．基类、派生类、成员对象类

单项选择题

有如下类定义和变量定义： class Parents{ public： int publicData； private： int 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．公有继承基类的公有成员
B．公有继承基类的私有成员
C．私有继承基类的公有成员
D．私有继承基类的私有成员

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class AA{ int k； protected： int n； void setK(int k){this-＞k=k；} public： void setN(int n){this-＞n=n；} }； class BB：public AA{／类体略／}； int main() { BB x； x．n=1；／／1 x．setN(2)；／／2 x．k=3；／／3 x.setK(4)；／／4 return 0； } 在标注号码的四条语句中正确的是( )。

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

单项选择题

有如下两个类定义 class xx{ private： double x1； protected： double：x2； public： double x3； }； class YY：protected XX{ private： double y1； potected： double y2； public： double y3； }；在类YY中保护成员变量的个数是( )。

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

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Music{ public： void setTitle(charstr){strcpy(title，str)；} protected： char type[10]； private： char title[20]； }； class Jazz：public Music{ public： void set(charstr){ strcpy(type，’’Jazz’’)；／／① strcpy(title，str)；／／② } }；下列叙述中正确的是( )。

A．程序编译正确
B．程序编译时语句①出错
C．程序编译时语句②出错
D．程序编译时语句①和②都出错

单项选择题

当派生类从一个基类保护继承时，基类中的一些成员在派生类中成为保护成员，这些成员在基类中原有的访问属性是( )。

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

单项选择题

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

A．派生类成员函数只能访问基类的公有成员
B．派生类成员函数只能访问基类的公有和保护成员
C．派生类成员函数可以访问基类的所有成员
D．派生类对基类的默认继承方式是公有继承

单项选择题

有如下类定义： class B{ public：void fun1(){} private：void fun2(){} protected：void fun3(){} }; class D：public B{ protected：void fun4(){} }；若obj是类D的对象，则下列语句中不违反访问控制权限的是( )。

A．pbj.fun1()；
B．obj．fun2()；
C．obj．fun3()；
D．obj．fun4()；

单项选择题

有如下程序： class Base{ public： int data； }； class Derivedl：public Base f}； }; class Derived2：protected Base{}； int main(){ Derivedl d1； Derived2 d2； d1．data=0; ／／① d2．data=0；／／② return 0； } 下列关于程序编译结果的描述中，正确的是( )。

A．①②皆无编译错误
B．①有编泽错误，②无编译错误
C．①无编译错误，②有编译错误
D．①②皆有编译错误

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class xx{ int x； public： XX(int xx=0)：x(xx){} int getX(){return x；} }； class YY：public xx{ int y； public： YY(int xx，int yy)：XX(xx)，y(yy){} int getV(){return getX()+y；} }； int main(){ YY c(3，4)； cout＜＜c．getV()+c．getX()＜＜endl； return 0； } 运行这个程序的输出结果是( )。

A．3
B．4
C．7
D．10

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Media{ public： void Name()； void Show()； protected： int page； }； class Book：private Media{public： void Print() {cout＜＜page＜＜endl；} void Show(){Media：：Show()；} ／／① }； int main(){ Book Bible； Bible．Name()；／／② Bible.Print()；／／③ Bible：Show()；／／④ return 0； }编译时有错误的是( )。

A．语句①
B．语句②
C．语句③
D．语句④

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class A{ public： A(){cout＜＜’’A’’；} }； classB{public：B(){cout＜＜’’B’’；}} classC：public A{ B b； public： C(){cout＜＜’’C’’；} }； int main(){C obj；return 0；} 执行后的输出结果是( )。

A．CBA
B．BAC
C．ACB
D．ABC

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class A { public： A(){cout＜＜’’A’’；} ～A(){cout＜＜’’～A’’；} }； class B：public A { A*p； public： B(){cout＜＜’’B’’；p=new A()；} ～B(){cout＜＜’’～Bt’’；delete p；} }； int main() { B obj； return 0； } 执行这个程序的输出结果是( )。

A．BAA～A～B～A
B．ABA～B～A～A
C．BAA～B～A～A
D．ABA～A～B～A

单项选择题

有如下程序 #include＜iostream＞ using namespace std； class Base{ protected： Base(){cout＜＜’A’；} Base(char c){cout＜＜c；} }； class Derived：public Base{ public： Derived(char c){cout＜＜c；} }； int main(){ Derived dl(’B’)； return 0； } 执行这个程序屏幕上将显示输出( )。

A．B
B．BA
C．AB
D．BB

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class A { public： A(int i){x=i；} void dispa，(){cout＜＜x＜＜’，’；} private： int x； }； class B：public A { public： B(int i)：A(i+10){x=i；} void dispb(){dispa()；cout＜＜x＜＜endl；}private int x： }； int main() { B b(2)； b．dispb()； return 0； } 运行时输出的结果是( )。

A．10，2
B．12，10
C．12，2
D．2，2

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Base{ int x； public； Base{int n=0}；x(n){cout＜＜n；} Int getX()const{return x；} }； class Derived public Base{ int y； public； Derived(int m，int n)：y(rn)，Base(n){cout＜＜m；} Derived(int m)：y(m){cout＜＜m；} }； int main(){ Derived dl(3)，d2(5，7)； return 0； } 运行时的输出结果是( )。

A．375
B．357
C．0375
D．0357

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class AA{ public： AA(){cout＜＜’1’；} }； class BB：public AA{ int k： public： BB()：k(0){cout＜＜’2’；} BB(int n)：k(n){cout＜＜’3’；} }； int main(){ BB b(4)，c； return 0； } 运行时的输出结果是( )。

A．1312
B．132
C．32
D．1412

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class C1{ public：～C1(){cout＜＜1；} }； class C2：public C1{ public：～C2(){cout＜＜2；} }； int main(){ C2 cb2； C1*cb1； return 0； } 运行时的输出结果是( )。

A．121
B．21
C．211
D．12

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Base{ public： Base(int x=0)：valB(x){cout＜＜valB；} ～Base(){cout＜＜valB；} private： int valB； }； class Derived：public Base{ public： Derived(int x=0，int y=0)：Base(x)，valD(y){cout＜＜valD；} ～Derived(){cout＜＜valD；} private： int valD； }； int main(){ Derived obj 12(2，3)； return 0； } 运行时的输出结果是( )。

A．2332
B．2323
C．3232
D．3223

单项选择题

生成派生类对象时，派生类构造函数调用基类构造函数的条件是( )。

A．无需任何条件
B．基类中显示定义了构造函数
C．派生类中显式定义了构造函数
D．派生类构造函数明确调用了基类构造函数

单项选择题

有如下类定义： class AA{ int a； Publie： AA(int n=0)：a(n){} }； class BB：public AA{public： BB(int n)_________ }；其中横线处缺失部分是( )。

A．：a(n){}
B．：AA(n){}
C．{a(n)；}
D．{a=n；}

单项选择题

有如下程序： #include＜iostream＞ using namespace std； class Basel{ public： Basel(int d) {cout＜＜d；} ～Base1(){} }； class Base2{ public： Base2(int d) {cout＜＜d；} ～Base2(){} }； class Derived：public Base1，Base2{ public： Derived(int a，int b，int c，int d)； Base1(b)，Base2(a)，b1(d)，b2(c){} Private： int b1； int b2； }； int main(){ Derived d(1，2，3，4)； return 0： } 运行时的输出结果是( )。

A．1234
B．2134
C．12
D．21

有如下两个类定义 class xx{ private： double x1； protected： double：x2； public： double x3； }； class YY：protected XX{ private： double y1； potected： double y2； public： double y3； }； 在类YY中保护成员变量的个数是( )。

你可能感兴趣的试题

建立一个有成员对象的派生类对象时，各构造函数体的执行次序为( )。

有如下类定义和变量定义： class Parents{ public： int publicData； private： int privateData； }； class ChildA：public Parents{／*类体略*／}; class ChildB：private Parents{／*类体略*／}； ChildA a； ChildB b； 下列语句中正确的是( )。

通过派生类的对象可直接访问其( )。

有如下两个类定义 class xx{ private： double x1； protected： double：x2； public： double x3； }； class YY：protected XX{ private： double y1； potected： double y2； public： double y3； }； 在类YY中保护成员变量的个数是( )。

当派生类从一个基类保护继承时，基类中的一些成员在派生类中成为保护成员，这些成员在基类中原有的访问属性是( )。

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

有如下类定义： class B{ public：void fun1(){} private：void fun2(){} protected：void fun3(){} }; class D：public B{ protected：void fun4(){} }； 若obj是类D的对象，则下列语句中不违反访问控制权限的是( )。

在一个派生类对象结束其生命周期时( )。

下列关于派生类构造函数和析构函数的说法中，错误的是( )。

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

有如下程序： #include＜iostream＞ using namespace std； class C1{ public： ～C1(){cout＜＜1；} }； class C2：public C1{ public： ～C2(){cout＜＜2；} }； int main(){ C2 cb2； C1*cb1； return 0； } 运行时的输出结果是( )。

生成派生类对象时，派生类构造函数调用基类构造函数的条件是( )。

有如下类定义： class AA{ int a； Publie： AA(int n=0)：a(n){} }； class BB：public AA{public： BB(int n)_________ }； 其中横线处缺失部分是( )。

有如下两个类定义 class xx{ private： double x1； protected： double：x2； public： double x3； }； class YY：protected XX{ private： double y1； potected： double y2； public： double y3； }；在类YY中保护成员变量的个数是( )。

有如下类定义和变量定义： class Parents{ public： int publicData； private： int privateData； }； class ChildA：public Parents{／类体略／}; class ChildB：private Parents{／类体略／}； ChildA a； ChildB b；下列语句中正确的是( )。

有如下两个类定义 class xx{ private： double x1； protected： double：x2； public： double x3； }； class YY：protected XX{ private： double y1； potected： double y2； public： double y3； }；在类YY中保护成员变量的个数是( )。

有如下类定义： class B{ public：void fun1(){} private：void fun2(){} protected：void fun3(){} }; class D：public B{ protected：void fun4(){} }；若obj是类D的对象，则下列语句中不违反访问控制权限的是( )。

有如下程序： #include＜iostream＞ using namespace std； class C1{ public：～C1(){cout＜＜1；} }； class C2：public C1{ public：～C2(){cout＜＜2；} }； int main(){ C2 cb2； C1*cb1； return 0； } 运行时的输出结果是( )。

有如下类定义： class AA{ int a； Publie： AA(int n=0)：a(n){} }； class BB：public AA{public： BB(int n)_________ }；其中横线处缺失部分是( )。