有如下程序:include using namespace std;class Base{public:Base(){ cout有如下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){ cout＜＜"BB";f(); } void f() { cout＜＜"Bf";} }; class Derived:public Base { public: Derived() { cout＜＜"DD"; } void f(
题目
有如下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){ cout＜＜"BB";f(); } void f() { cout＜＜"Bf";} }; class Derived:public Base { public: Derived() { cout＜＜"DD"; } void f(){ cout＜＜"Df"; } }; int main(){ Derived d; return 0;}执行上面的程序将输出______ 。
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
相似考题
更多“有如下程序:include using namespace std;class Base{public:Base(){ cout 有如下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){ cout＜＜"BB";f(); } void f() { cout＜＜"Bf";} }; class”相关问题
-
第1题：
以下程序的执行结果为______。includeusing namespace std; class base { public: vir 以下程序的执行结果为______。
include＜iostream＞
using namespace std;
class base
｛
public：
virtual void who()
｛
cout＜＜"base class"＜＜endl;
｝
｝;
class derivel：public base
｛
public：
void who()
｛
cout＜＜"d
正确答案：base class derivel class derive2 class
base class derivel class derive2 class -
第2题：
有如下程序:includeusing namespace std;class Base{public:Base(){cout<<"BB"; f() 有如下程序：#include ＜iostream＞using namespace std;class Base{ public: Base(){cout＜＜"BB"; f(); } Void f(){cout＜＜"Bf"; }};class Derived: public Base{ public: Derived() { cout＜＜"DD"; } void f() { cout＜＜"Df"; }};int main() { Derived d; return 0; }执行上面的程序将输出( )。
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
-
第3题：
有如下程序:includeusing namespace std;class Base{protected:Base(){cout<<'Base'; 有如下程序： #include＜iostream＞ using namespace std; class Base{ protected: Base(){cout＜＜'Base';} Base(char c){cout＜＜c;} }; class Derived:public Base{ public: Derived(char c){cout＜＜c;} }; int main(){ Derived d('Derived'); return 0; } 执行这个程序屏幕上将显示输出( )。
A．Derived
B．DerivedBase
C．BaseDerived
D．DerivedDerived
正确答案：C
解析：派生类Derived由基类Base公有派生，在派生类构造函数声明时系统会自动调用基类的缺省构造函数。调用Derived d('Derived')；后，执行类Derived构造函数的Derived(char c)，系统自动调用基类的缺省构造函数Base()，输出字母Base；再执行派生类的构造函数Derived(char c)，输出字母Derived。 -
第4题：
有如下程序:includeusing namespace std;class Base{public:Base(int x=0){cout< 有如下程序： #include＜iostream＞ using namespace std； class Base{ public： Base(int x=0){cout＜＜x；} }； class Derived：public Base{ public： Derived(int x=0){cout＜＜x；} private： Base val； }； int main( ){ Derived d(1)； return 0； } 程序的输出结果是
A．0
B．1
C．01
D．001
正确答案：D
解析：派生对象在创建时先调用基类的构造函数，然后调用派生类的构造函数；撤销对象时，先调用派生类的构造函数，然后调用基类的构造函数。当类中出现其他类对象时，在初始化时先调用该对象的类的构造函数创建该对象。第5题：
有如下程序:includeusing namespace std;class Base{public:Base(){ cout<<"BB"; 有如下程序： #include ＜iostream.h＞ using namespace std; class Base { public: Base(){ cout＜＜"BB"; f(); } voidf(){cout ＜＜"Bf"; } }; class Derived: public Base { public: Derived (){cout＜＜"DD";} void f(){cout＜＜"Df";} }; int main(){Derived d; return 0;} 执行上面的程序将输出
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析：本题考核类的继承与派生知识。派生类构造函数执行的一般次序如下：首先调用基类构造函数，调用顺序按照它们被继承时说明的顺序。然后调用子对象的构造函数，调用顺序按照它们在类中的说明顺序。最后是派生类构造函数中的内容。题中定义派生类对象d时，先调用基类Base的构造函数输出BBBf(注意：基类Base构造函数中调用的函数f()是基类中的实现，而不是派生类中的实现)，然后调用派生类Derived的构造函数输出DD。第6题：
有如下程序:includeusing namespace std;class Base{ public: void fun() { cout<<" 有如下程序： #include ＜iostream＞ using namespace std; class Base { public: void fun() { cout＜＜"Base::fun"＜＜endl; } }; class Derived : public Base { public: void fun() { ______ cout＜＜"Derived::fun"＜＜endl; } }; int main() { Derived d; d.fun(); return 0; } 已知其执行后的输出结果为： Base::fun Derived::fun 则程序中下划线处应填入的语句是( )。
A．Base.fun();
B．Base::fun();
C．Base-＞fun();
D．fun();
正确答案：B
解析：此题考查的是继承的使用。分析题目可知，横线处应填入对基类成员函数fun()的调用语句，此处只能使用作用域运算符“::”才能调用到基类的同名函数。第7题：
下面程序的输出结果是【】。includeusing namespace std; class base { protected: int 下面程序的输出结果是【 】。
include ＜iostream＞
using namespace std;
class base
{
protected:
int a;
public:
base(){cout＜＜"0":}
};
class basel: virtual public base
{
public:
base1(){ cout＜＜"1";}
};
class base2 : virtual public base
{
public:
base2(){cout＜＜"2";}
};
class derived : public base1,public base2
{
public:
derived () {cout＜＜"3"; }
}
int main ()
{
derived obj;
cout＜＜end1;
return 0;
}
正确答案：0123
0123 解析：本题考核含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最有调用派生类自己的构造函数．题中先调用base的构造函数，然后调用base1、base2的构造函数，最后调用derived的构造函数。第8题：
下列程序的输出结果为2,请将程序补充完整。 includeusing namespace std; class Base 下列程序的输出结果为2，请将程序补充完整。
include＜iostream＞
using namespace std；
class Base
{
public：
______void fun(){cout＜＜1；}
}；
class Derived：public Base
{
public：
void fun(){cout＜＜2；}
}；
int main()
{
Base*p=new Derived；
p-＞fur()；
delete p；
return 0；
}
正确答案：virtual
virtual 解析：本题考核虚函数的概念。在C++中，一个基类指针(或引用)可以用于指向它的派生类对象，而且通过这样的指针(或引用)调用虚函数时，被调用的是该指针(或引用)实际指向的对象类的那个重定义版本，这样的调用称为多态调用。基类Base和派生类Derived中都定义了成员函数fun，但是有不同的实现。程序最后输出的结果为2，表明通过对象指针p调用的函数版本为派生类中定义的，只有把基类的fun函数定义为虚函数，才能满足要求。第9题：
有如下程序:includeusing namespace std;class AA{public: virtual void f() {cout< 有如下程序: #include ＜iostream＞ using namespace std; class AA { public: virtual void f() { cout＜＜ "AA"; } }; class BB : public AA { public: BB() { cout ＜＜ "BB"; } }; cla
A．AA
B．AABBCC
C．BBAABBCC
D．BBBBAACC
正确答案：D
解析：本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。最后执行语句“p=&cc； p-＞f()；”，输出AA和CC。第10题：
有下列程序: includeusing namespace std; class Base { public: Base(){cout<<"B 有下列程序： #include＜iosteram.h＞ using namespace std; class Base { public: Base(){cout＜＜"BB"; f(); } void f(){cout＜＜"Bf";} }; class Derived:public Base { public: Derived(){cout＜＜"D
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析： 此题考查的是类的继承和派生。派生类执行构造函数的一般次序：首先调用基类构造函数；然后调用成员对象的构造函数；最后是派生类构造函数中的内容。题目中定义派生类对象d时，先调用基类Base的构造函数，输出BBBf，然后调用派生类Derived的构造函数，输出DD。第11题：
有如下程序includeusing namespace std;class Base{protected:Base(){cout<<'A';}Bas 有如下程序 #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
正确答案：C
第12题：
请在如下程序中的空格处填写正确的语句: includeusing namespace std; class Base { 请在如下程序中的空格处填写正确的语句：
include ＜iostream＞
using namespace std;
class Base {
public:
void fun() {cout＜＜"Base fun"＜＜endl; }
};
class Derived: public Base {
public:
void fun() {
【 】; //调用基类的函数fun()
cout＜＜"Derived fun "＜＜endl;
}
};
正确答案：Base::fun()
Base::fun() 解析：本题考查的知识点是：派生类对基类成员的访问。本题的派生类Derived覆盖了基类Base中的fun()，如需调用基类版本的fun()，则需要使用域运算符“::”。故应该填写Base::fun()。第13题：
有以下程序:includeusing namespace std;class Base{public: Base(){} virtual void 有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){} virtual void f1() { cout＜＜"f1 of base"＜＜end1; } ～Base(){} }; class Derive: public Base { public: void fl(int x) { cout＜＜"f1 of derive"＜＜end1; } }; int main ( ) { Base *p; Derive obj1; p=&obj 1; p-＞f1 ( ); return 0; }
A．编译时出错
B．f1 of derive
C．f1 of base
D．以上答案都不对
正确答案：B
解析：本程序中，将基类的成员函数n()定义为虚函数，而函数f1()在派生类中被重新定义，重定义的函数仍然是一个虚函数。在C++中，一个基类指针(或引用)可以指向它的派生类对象，而且通过这样的指针或引用调用虚函数时，被调用的是该指针(或引用)实际所指向的对象类的那个重定义版本。第14题：
有如下程序: includeusing namespace std; class BASE { public 有如下程序： #include＜iostream＞ using namespace std; class BASE { public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE { public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVEDx;retum 0;} 执行后的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：本题考查基类析构函数和派生类析构函数的调用次序。第15题：
如下程序的输出是includeusing namespace std;class Base{public:Base( ){cout<<"BB" 如下程序的输出是 #include＜iostream＞ using namespace std； class Base{ public： Base( ){cout＜＜"BB"；f( )；} void f( ){cout＜＜"Bf"；} }； class Derived：public Base{ public： Derived( ){eout＜＜"DD"；} void f( ){cout＜＜"Df"；} }； int main( ){Derived d；return 0；}
A．BBBff)D
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析：当创建派生类对象时，首先调用基类的构造函数，最后调用派生类的构造函数。第16题：
有如下程序:includeusing namespace std;class Base{public:void output( ){cout< 有如下程序： #include＜iostream＞ using namespace std； class Base{ public： void output( ){cout＜＜l；} virtual void Print( ){cout＜＜'B'；} }； class Derived：public Base{ public： void output( ){cout＜＜1；} void Print( ){cout＜＜'D'；} }； int main( ){ Base*prt=new Derived； prt-＞output( )； prt-＞Print( )； delete prt； return 0； } 程序的输出结果是
A．1B
B．1D
C．2B
D．2D
正确答案：B
解析：基类指针可以指向派生类对象，但是只能访问从基类中继承来的成员。派生类对从基类继承来的成员可以被重新定义。故打印1D第17题：
有如下程序:includeusing namespace std;class BASE{public:~BASE(){cout<<"BASE";} 有如下程序： #include ＜iostream＞ using namespace std; class BASE{ public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE{ public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVED x;return 0;} 执行后的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：本题考核派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。所以当main函数结束时，派生类DERIVED的对象x将被删除，那么派生类DERIVED的析构函数先被调用，输出DERIVED，然后调用基类的析构函数输出BASE。第18题：
有如下程序:includeusing namespace std;class BASE{public:~BASE( ){cout<<"BASE";} 有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE( ){cout＜＜"BASE"；} }； class DERIVED：public BASE{ public： ～DERIVED( ){cout＜＜"DERIVED"；} }； int main( ){DERIVED x；return 0；} 程序的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：基类和派生类的析构函数的执行顺序是先执行派生类的析构函数，最后执行基类的析构函数；故先执行DIVERED的析构函数，后执行BASE的析构函数。第19题：
执行如下程序将输出():includeusing namespace std;class Base{public:Base(){cout<< 执行如下程序将输出( ): #include＜iostream＞ using namespace std; class Base { public: Base(){cout＜＜"BB";fun();} void fun (){tout＜＜"Brim";} }; class Derived:public Base { public: Derived(){cout＜＜"DD";} void fun (){cout＜＜"Dfun";} }; int main(){Derived d;return 0;}
A．DD
B．BBDfunDDDfun
C．BBBfunDD
D．DDBBBfun
正确答案：C
解析：C++中创建一个类的实例时，如果该类存在基类，将首先执行基类的构造函数，然后执行该类本身的构造函数。本题中首先执行类Base的构造函数，所以将先输出“BB”，然后调用基类成员函数fun()，输出“Bfun”，最后调用子类Derived的构造函数输出“DD”。第20题：
有如下程序:includeinclude using namespace std;class BASE{char c;public 有如下程序： #include＜iostream＞#include＜iosream＞ using namespace std； class BASE{ char c； public； BASE(char n)：c(n){} virtual ～ BASE(){cout＜＜c;} }； class DERIVED; public BASE{ char c； public： DERIVED (char n): BASE (n+1)
A．XY
B．YX
C．X
D．Y
正确答案：A
第21题：
有如下程序:includeusing namespace std;class Base{private:charc;public:Base(cha 有如下程序：#include ＜iostream＞using namespace std;class Base{private: char c;public: Base(char n) :c(n){} ～Base() { cout＜＜c; } };class Derived: public Base{private: char c; public: Derived(char n):Base(n+1),c(n) {} ～Derived() { cout＜＜c; }};int main (){ Derived obj ('x'); return 0;}执行上面的程序净输出
A．xy
B．yx
C．x
D．y
正确答案：A
解析：在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。在此题的程序中，在主函数main结束时，派生类Derived对象obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出x，然后调用基类的析构函数，输出y。第22题：
有如下程序:ncludeusing namespace std;class Base{public:void fun1() {cout << "B 有如下程序:#nclude ＜iostream＞using namespace std;class Base{ public:void fun1() {cout ＜＜ "Base\n"; }virtual void fun2() {cout ＜＜ "Base\n"; }};class Derived: public Base{ public:void fun1() {cout ＜＜ "Derived\n"; }void fun2() {cout ＜＜ "Derived\n"; }} void f(Base& b) { B. fun1(); B. fun2(); }int main(){Derived obj;f(obj);return 0;}
A．Base Base
B．Base Derived
C．Derived Base
D．Derived Derived
正确答案：B
第23题：
有如下程序:includeusing namespace std;class BASE{public:~BASE(){cout<<"BASE";}} 有如下程序： #include＜iostream＞ using namespace std; class BASE{ public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE{ public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVED x;return 0;} 执行后的输出结果是( )。
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：此题考查的是派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。第24题：
请在下列程序的横线处填写正确的语句。includeusing namespace std; class Base{ publ 请在下列程序的横线处填写正确的语句。
include＜iostream＞
using namespace std;
class Base{
public:
void fun(){cout＜＜"Base fun"＜＜endl;}
};
class Derivde:public Base{
public:
void fun(){
______∥ 调用基类的函数
正确答案：Base∷fun()
Base∷fun() 解析： 此题考查的是派生类对基类成员的访问。本题中派生类Derived覆盖了基类Base中的fun()，如果需要调用基类中的fun()，则需要使用域运算符“∷”。故应填写Base∷fun()。