有如下两个类定义 c1ass XX{ private: ...

单项选择题

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

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

单项选择题

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

A．cout＜＜a．publicData＜＜end1;
B．cout＜＜a．privateData＜＜end1;
C．cout＜＜b．publicData＜＜end1;
D．cout＜＜b．privateData＜＜end1;

单项选择题

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

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

单项选择题

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

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

单项选择题

有如下程序： #inc1ude＜iostream＞ using namespace std; c1ass Music{ public: void setTitle(char* str){ strcpy(title, str);} protected: char type[10]； private: char title[20]; }； c1ass Jazz: public Music{ public: void set(char* str){ strcpy(type,¨Jazz¨); ／／① slrcpy(title,str); ／／② } }；下列叙述中正确的是( )。

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

单项选择题

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

A．obj．funl();
B．obj．fun2();
C．obj．fun3();
D．obj．fun4();

单项选择题

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

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

单项选择题

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

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

单项选择题

有如下程序： #inc1ude＜iostream＞ using namespace std; c1ass Media{ public: void Name(); void Show(); protected: int page; }； c1ass Book: private Media{ public: void Print() {cout＜＜page＜＜end1;} void Show0{Media::Show0;)//① }； int rruun(){ Book Bible; Bible．Name();，//② Bible．Print();//③ Bible．Show();//④ retum ()； }编译时有错误的是( )。

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

单项选择题

有如下程序： #inc1ude ＜iostream＞ using namespace std; c1ass A{ public: AO{cout＜＜A";} }； c1assB {public:BO {cout＜＜"B";}} c1assC:public A{ B b； public: C(){cout＜＜"C"；} }； int main0{Cobj;retum 0;} 执行后的输出结果是( )。

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

单项选择题

有如下程序： #iinc1ude ＜iostream＞ us:ing namespace std; c1assA { public: AO{cout＜＜"A"；} ~AO{cout＜＜"~A"；} }； c1ass B：public A { A*p； public: B(){cout＜＜"B";p=new A();} ~B(){cout＜＜"~B";delete p;} }； int main() { B obj; return ()； } 执行这个程序的输出结果是( )。

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

单项选择题

有如下程序 #inc1ude＜iostream＞ using namespace std; c1ass Base{ protected: Base(){cout＜＜’A’；} Base(charc){cout＜＜c;} }； c1ass Derived: public Base{ public: Derived( char c){cout＜＜c,) }； int main(){ Derived dl(’B’)； return0； } 执行这个程序屏幕上将显示输出( )。

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

单项选择题

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

A．先调用派生类的析构函数后调用基类的析构函数
B．先调用基类的析构函数后调用派生类的析构函数
C．如果基类没有定义析构函数，则只调用派生类的析构函数
D．如果派生类没有定义析构函数，则只调用基类的析构函数

单项选择题

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

A．派生类的构造函数会隐含调用基类的构造函数
B．如果基类中没有缺省构造函数，那么派生类必须定义构造函数
C．茬建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数
D．在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

单项选择题

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

A．派生类不能访问基类的保护成员
B．作为虚基类的类不能被实例化
C．派生类应当向基类的构造函数传递参数
D．虚函数必须在派生类中重新实现

单项选择题

有如下程序： #inc1ude＜iostream＞ using namespace std; c1assA { public: A(int i){x=i；) void dispa(){cout＜＜x＜＜’,’;} private: int x； }； c1ass B：public A { public: B(int i):A(i+10){x=i;) void dispb(){dispa();cout＜＜x＜＜ end1;} private int x； }； int main() { B b(2)； b．dispb()； retum 0； } 运行时输出的结果是( )。

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

单项选择题

有如下程序： #inc1ude＜iostream＞ using namespace std; c1ass Base{ int x： public; Base{int w=0}; x(n){cout＜＜n;} Int getX()const {return x;} }； c1ass Derived public Base{ int y； public; Derived(int m, int n): y(m), Base(n){cout＜＜m,} Derived(int m): y(m){cout＜＜m;) }； int main(){ Derived d1(3), d2(5,7); Retum 0； } 运行时的输出结果是( )。

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

单项选择题

有如下程序： #inc1ude ＜iostream＞ using namespace std; c1ass AA{ public: AAO{ cout＜＜’1’； } }； c1ass BB: public AA{ int k； public: BB():k(0){cout＜＜’2’; } BB(intn):k(n){ cout＜＜’3’； } }； int main0{ BB b(4),c； return 0； } 运行时的输出结果是( )。

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

单项选择题

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

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

单项选择题

有如下程序： #inc1ude ＜iostream＞ using namespace std; c1ass Base{ public: Base(int x==0):valB(x){cout＜＜va1B,} ～Base(){cout＜＜valB,) private: int vaIB; }； c1ass Derived:public Base{ public: Derived(int x=0,int y=0):Base(x),vaID(y){cout＜＜va1D,} ～Derived0 {cout＜＜valD;} private: int vaID; }； int main(){ Derived obj12(2,3); retum0； } 运行时的输出结果是( )。

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

单项选择题

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

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

单项选择题

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

A．:n){}
B．:AA(n){}
C．{a(n);}
D．{a==n;}

单项选择题

有如下程序： #inc1ude ＜iostream＞ using namespace std; c1ass Basel{ public: Basel(int d) {cout＜＜d;) ～Base1(){} }； c1ass Base2{ public: Base2(int d) {cout＜＜d;} ～Base2(){} }； c1ass 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); return 0； } 运行时的输出结果是( )。

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

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

你可能感兴趣的试题

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

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

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

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

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

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

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

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

有如下程序： #inc1ude ＜iostream＞ using namespace std; c1ass A{ public: AO{cout＜＜A";} }； c1assB {public:BO {cout＜＜"B";}} c1assC:public A{ B b； public: C(){cout＜＜"C"；} }； int main0{Cobj;retum 0;} 执行后的输出结果是( )。

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

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

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

有如下程序： #inc1ude ＜iostream＞ using namespace std; c1ass AA{ public: AAO{ cout＜＜’1’； } }； c1ass BB: public AA{ int k； public: BB():k(0){cout＜＜’2’; } BB(intn):k(n){ cout＜＜’3’； } }； int main0{ BB b(4),c； return 0； } 运行时的输出结果是( )。

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

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

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

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

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

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

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

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

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