将下面程序补充完整。 include using namespace std; class Base{ public: 【】fun(){r将下面程序补充完整。include ＜iostream＞using namespace std；class Base{public：【】 fun(){return 0；} //声明虚函数}；class Derived：public Base{public：x，y；void SetVal(int a，int b){}int fun(){return x+y；}}；v

题目

将下面程序补充完整。 include using namespace std; class Base{ public: 【】fun(){r

将下面程序补充完整。

include ＜iostream＞

using namespace std；

class Base{

public：

【】 fun(){return 0；} //声明虚函数

}；

class Derived：public Base{

public：

x，y；

void SetVal(int a，int b){}

int fun(){return x+y；}

}；

void 【】 SetVal(int a，int b){x=a；y=b；} //类Derived成员函数

void main(){

Derived d；

cout＜＜d．fun()＜＜endl；

}

相似考题

1.有如下程序：#include +using namespace std ；#includeusing namespace std;class Base{public:void fun(){cout<<"Base::fun"<};class Derived:public Base{public:void fun(){cout<<"Derived::fun"<}};int main(){Derived d;d.fun();return 0;}已知其执行后的输出结果为：Base::funDerived::fun则程序中下划线处应填入的语句是A ． Base.fun();B ． Base::fun()C ． Base->fun()D ． fun();

2.下列程序中划线处正确的语句是()。 include using namespace std;class Base{public:v下列程序中划线处正确的语句是( )。 # include ＜iostream＞ using namespace std； class Base { public： void fun(){cout＜＜"Base:: fun" ＜＜endl；} }； class Derived：public Base { void fun() { ______ ∥显式调用基类的函数fun() cout＜＜"DA．fun()；B．Base．fun()；C．Base::fun()；D．Base- ＞fun()；

3.有如下程序: include using namespace std; class Base { public:有如下程序： #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．0B．1C．1D．1

4.有如下程序 include using namespace std; class Base { protected:有如下程序 #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 d1 ('B'); return 0; } 执行这个程序屏幕上将显示输出A．BB．BAC．ABD．BB

参考答案和解析

正确答案：virtual int Derived：：
virtual int Derived：：解析：virtual int用于声明虚函数；Derived：：用于指定类Derived成员函数。

更多“将下面程序补充完整。 include using namespace std; class Base{ public: 【】fun(){r 将下面程序补充完整。include ＜iostream＞using namespace std；class Base{public：【】 fun(){return 0；} //声明虚函数}；class Derived：public Bas”相关问题

第1题：

下面程序的输出结果为:Base:: fun,请将程序补充完整。include class Base{public: 【】

下面程序的输出结果为：Base:: fun，请将程序补充完整。
include ＜iostream.h＞
class Base{
public:
【】 fun(){cout＜＜"Base::fun"＜＜end1:}
class Derived : public Base{
public:
【】 fun(){ cout＜＜"Derived::fun"＜＜end1; }
};
int main()
{
Base a,*pb;
Derived b;
pb = &b;
pb-＞fun();
return 0;
}

正确答案：virtual void void
virtual void void 解析：本题考核虚函数的使用。在C++中，一个基类指针(或引用)可以用于指向它的派生类对象，而且通过这样的指针(或引用)调用虚函数时，被调用的是该指针(或引用)实际指向的对象类的那个重定义版本，这样的调用称为多态调用。基类Base和派生类Derived中都定义了成员函数fun，但是有不同的实现。程序最后输出的结果为：Base::fun，表明通过对象指针pb调用的函数版本为派生类中定义的，只有把基类的fun函数定义为虚函数，才能满足要求。同时通过函数fun的定义可知函数的返回类型为void。
第2题：

有如下程序: include using 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
解析：本题考查基类析构函数和派生类析构函数的调用次序。
第3题：

请在下列程序中的横线处填写正确的语句。include using namespace std; class Base{ pu

请在下列程序中的横线处填写正确的语句。
include＜iostream＞
using namespace std;
class Base{
public：
void fun(){cout＜＜“Basefun”＜＜endl；}
);
class Derivde：public Base{
public：
void fun(){
//调用基类的函数fun()
cout＜＜“Derived fun”＜＜endl；
}
}；

正确答案：Base：：fun()。
Base：：fun()。解析：本题考查的是派生类对基类成员的访问。本题中派生类Derived覆盖了基类Base中的fun ()，如果需要调用基类中的fun()，则需要使用域运算符“：：”。故应填写Base：：fun()。
第4题：

有以下程序:include using namespace std; class Base { public: Base() { K=0; } int

有以下程序：
include＜iostream＞
using namespace std；
class Base
{
public：
Base()
{
K＝0；
}
int x；
}；
class Derivedl：virtual public Base
{
public：
Derivedl()
{
x＝10；
}
}；
class Derived2：virtua1 public Base

正确答案：20。
20。解析：本题中，虽然Derived1和Derived2由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1中修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obi；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x＝20。最后输出x的值为20。
第5题：

有如下程序:include using 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()的调用语句，此处只能使用作用域运算符“::”才能调用到基类的同名函数。
第6题：

下面程序的输出结果是【】。include using 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的构造函数。
第7题：

下列程序的输出结果为2,请将程序补充完整。 include using 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函数定义为虚函数，才能满足要求。
第8题：

下面程序的打印结果是【】。 include using namespace std; class Base { public:Base(i

下面程序的打印结果是【】。
include ＜iostream＞
using namespace std;
class Base
{
public:
Base(int x)
{
a=x;
}
void show()
{
cout＜＜a;
}
private:
int a;
};
class Derived : public Base
{
public:
Derived(int i) :Base(i+1) ,b(i) { }
void show()
{
cout＜＜b;
}
private:
int b;
};
int main ( )
{
Base b(5) , *pb;
Derived d(1);
pb=&d;
pb-＞show();
return 0;
}

正确答案：2
2 解析：基类Base派生出派生类Derived，在主函数中，定义了基类对象b，基类指针pb，以及派生类对象d，并让基类指针pb指向派生类对象乙在C++中，当派生类的对象赋值给基类对象时，只能使用派生类对象中从基类继承的成员。所以最后执行语句“pb-＞show()；”是调用基类的成员函数show()，输出a的值2。
第9题：

下列程序的输出结果为2,请将程序补充完整。 include using namespaee std; class B

下列程序的输出结果为2，请将程序补充完整。
include ＜iostream＞
using namespaee std；
class Base{
public：
______void fun( ){cout＜＜1；}
}；
class Derived:public Base{
public：
void fun( ){cout＜＜2；}
}；
int main( ){
Base*P=new Derived：
p-＞fun( )；
delete P；
return 0；
}

正确答案：virtual
virtual 解析：在基类中的虚函数在派生类中被重新定义时，该函数仍然为虚函数，但是可以省略不写virtual关键字，在派生类对象中调用时，则调用被重新定义后的虚函数。
第10题：

有如下程序: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
解析：此题考查的是派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。
第11题：

请在如下程序中的空格处填写正确的语句: include using 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()。
第12题：

在下面横线上填上适当的语句,完成程序。include using namespace std; class Base { in

在下面横线上填上适当的语句，完成程序。
include＜iostream＞
using namespace std；
class Base
{
int x；
public：
Base(int i){x＝i；}
～Base(){}
)；
class Derived：public Base
{
public：
______//完成类Derive构造函数的定义
};
iht main()
{
Derived obj

正确答案：Derived(int i；Base(i){}。
Derived(int i；Base(i){}。解析：程序中，类Derived是基类Base的公有派生。在类Derived的构造函数应该包括调用基类构造函数使基类的数据成员得以初始化，
第13题：

有如下程序:include using 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
第14题：

下列程序的输出结果为2,请将程序补充完整。 inelude using namespace std; class Bas

下列程序的输出结果为2，请将程序补充完整。
inelude＜iostream.h＞
using namespace std;
class Base
{
public:
______ void fun( ){cout＜＜1;}
};
class Derived: public Base
{
pbulic:
void fubn( ){cout＜＜2;}
};
int main( )
{Base*P=new Derived;
P→fun( );
delete P;
return 0;
}

正确答案：virtual
virtual 解析：本题考查虚函数的概念。在C++中，一个基类的指针可以用于指向它的派生类对象。而且通过这样的指针调用虚函数时，被调用的是该指针实际指向的对象类的那个重定义版本。在本题中，通过对象指针P调用的是派生类中重定的。fun函数，那么基类中的fun只有是虚函数才能满足要求。
第15题：

下列程序的输出结果为2,请将程序补充完整。 include using namespace std; class Basc

下列程序的输出结果为2，请将程序补充完整。
include＜iostream＞
using namespace std;
class Basc
{
public:
【】void fun(){cout＜＜1;}
};
class Dcrived:public Base
{
public:
void fun(){cout＜＜2；}
};
int main()
{
Base*p=new Derived;
p-＞fun();
delete p;
return 0;
}

正确答案：virtual
virtual 解析：利用虚函数实现多态。
第16题：

有如下程序:include using 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。
第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
解析：基类和派生类的析构函数的执行顺序是先执行派生类的析构函数，最后执行基类的析构函数；故先执行DIVERED的析构函数，后执行BASE的析构函数。
第18题：

执行如下程序将输出():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”。
第19题：

有如下程序:include using namespace std;class Base{public:void fun() {cout<<"Bas

有如下程序：#include ＜iostream＞using namespace std;class Base { public: void fun() {cout＜＜"Base:: fun"＜＜end1; }};class Derived: public Base ( public: void fun() { ____________________________ cout＜＜"Derived:: fun"＜＜end1; }};int main() { Derived d; D. fun(); return O;}已知其执行后的输出结果为：Base:: funDerived:: fun则程序中下划线处应填入的语句是( )。
A．Base. fun ()；
B．Base:: fun ()；
C．Base-＞fun()；
D．fun()

正确答案：B
第20题：

有如下程序: include using namespace std; class Base { public:

有如下程序： #include＜iostream＞ using namespace std; class Base { public: void fun() { cout＜＜"Base::fun"＜＜endl; } }; class Derived: public Base { public: void tim() } ____________ cout＜＜"Derived:: fun"＜＜endl; } }; int main() { Derived d; d.fun(); return O; } 已知其执行后的输出结果为： Base::fun Derived::fun 则程序中下划线处应填入的语句是
A．Base.fun()；
B．Base::fun()；
C．Base-＞fun()；
D．fun()；

正确答案：B
解析：本题考查的知识点是继承的运用。题目中要求的两行输出结果分别在基类的成员函数fun()与派生类的成员函数fun()中给出，而主函数中只通过派生类对象d调用fun()函数，即只调用了派生类的成员函数fun()。所以，横线处应该填入对基类成员函数fun()的调用语句，此处只能使用作用域运算符“::”才能调用到基类中的同名函数，故应该选择B。
第21题：

有如下程序:include using namespace std;class Base{private:char c;public:Base(ch

有如下程序:#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
第22题：

下列程序中划线处正确的语句是()。include using namespace std;class Base{public:vo

下列程序中划线处正确的语句是( )。#include ＜iostream＞using namespace std;class Base{public:void fun() { cout＜＜"Base:: fun"＜＜end1; }};class Derived: public Base{ void fun() { _______________________ //显试调用基类的函数 fun() cout ＜＜"Derived:: fun"＜＜end1;};
A．fun();
B．Base. fun();
C．Base:: fun();
D．Base-＞fun();

正确答案：C
第23题：

请在下列程序的横线处填写正确的语句。include using 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()。

itgle.com

题目

相似考题

参考答案和解析

更多“将下面程序补充完整。 include using namespace std; class Base{ public: 【】fun(){r 将下面程序补充完整。include ＜iostream＞using namespace std；class Base{public：【】 fun(){return 0；} //声明虚函数}；class Derived：public Bas”相关问题

相关内容

itgle.com

题目

相似考题

参考答案和解析

更多“将下面程序补充完整。 include using namespace std; class Base{ public: 【 】fun(){r 将下面程序补充完整。include ＜iostream＞using namespace std；class Base{public：【 】 fun(){return 0；} //声明虚函数}；class Derived：public Bas”相关问题

相关内容

更多“将下面程序补充完整。 include using namespace std; class Base{ public: 【】fun(){r 将下面程序补充完整。include ＜iostream＞using namespace std；class Base{public：【】 fun(){return 0；} //声明虚函数}；class Derived：public Bas”相关问题