下面程序的结果是 ______。includeclass A{ public:virtual voidfun()=0{};};class下面程序的结果是 ______。 #include＜iostream.h＞ class A{ public: virtual void fun()=0{}; }; class B:public A{ public: void fun () {cout＜＜ "new file" ;} }; class C: public A{ public: void fun (){cou
题目
下面程序的结果是 ______。 #include＜iostream.h＞ class A{ public: virtual void fun()=0{}; }; class B:public A{ public: void fun () {cout＜＜ "new file" ;} }; class C: public A{ public: void fun (){cout＜＜"open file"＜＜ " " } }; class D: public A{ public: void fun () {cout＜＜ "save file\n" ;} }; void main() { A a,*p; B b; C c; D d; p=&c; p-＞fun (); p=&b; p-＞fun (); p=&d; p-＞fun(); }
A．new file open file save file
B．new file new file new file
C．编译出错
D．open file new file save file
相似考题
更多“下面程序的结果是 ______。#include<iostream.h>class A{ public:virtual voidfun()=0{};};class ”相关问题
-
第1题：
下面程序的运行结果是 ______。includeclass A{public virtual、~(){cout<<”call A:: 下面程序的运行结果是 ______。 #include＜iostream.h＞ class A{ public virtual、~(){ cout＜＜”call A:: ～A()”＜＜end1；} }； class B：public A{ B(int i){p=new char[i]：} -B(){ delete[)p； Cout＜＜”call B:: ～B()”; } }； void main() { A*a=new B(8)； Delete a； }
A．call B:: ～B()
B．call B:: ～B()
C．call A：～A()
D．call A::～A()
正确答案：A
-
第2题：
下列程序的运行结果是______。 includeclass A { public: virtual void use( ) {cou 下列程序的运行结果是______。
include＜iostream.h＞
class A
{
public:
virtual void use( ) {cout＜＜"in A\n";}
};
class B:public A
{
public:
virtual void use( ) {cout＜＜"in B\n";}
};
class C:public B
{
public:
virtual void use( ){cout<<"in C\n";}
};
void main( )
{
A*obj；
bj=new C;
obj-＞use( );
delete obj;
}
正确答案：in C
in C 解析：本题考查虚函数和多态性。原本obj指向祖先类，随后被赋值，指向新的子孙类，则在使用use这个重载的虚函数时，根据当前指向可确定调用子孙的同名虚函数。 -
第3题：
有以下程序:includeusing 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。 -
第4题：
下面程序的结果是includeclass A{public:A( ){cout<<"construtA"< 下面程序的结果是 #include＜iostream.h＞ class A { public： A( ) {cout＜＜"construtA"＜＜endl；} virtual~A( ) {cout＜＜"destructA"＜＜endl；}}； class B：public A {}； class C：public A {}； c
A．constructA destructA
B．constructA constructA destructA destructA
C．constructA constructA constructA destructA destructA destructA
D．constructA onstructA constructA constructA destructA destructA destructA destructA
正确答案：B
解析：类D继承了类C和类B，所以在构造的时候分别构造类B和类C。第5题：
下面程序的输出结果是includeclass A{public: A( ) {cout < < "construtA" < < end 下面程序的输出结果是 #include＜iostream.h＞ class A { public: A( ) {cout ＜ ＜ "construtA" ＜ ＜ endl;} Virtual~A( ) {cout ＜ ＜ "destructA" ＜ ＜ endl;}}; class B: public A { }; class C:public A { }; class D:public B,public C { }; void main( ) { D d;}
A．constructA
B．constructA
C．constructA
D．constructA destructA constructA constructA constructA destructA constructA constrnctA destructA destructA constructA destructA destructA destructA destrctA destructA destructA
正确答案：B
解析：类D继承了类C和类B，所以在构造的时候分别构造类B和类C。第6题：
下面程序的运行结果是includeclass base{protected:int a;public:base( ){cout<<"0 下面程序的运行结果是 #include＜iostream.h＞ class base{ protected： int a； public： base( ){cout＜＜"0"；} }； class basel：virtual base { public： base1( ){cout＜＜"1"；} }； class base2：virtual base{ public：
A．123
B．3120
C．312
D．3012
正确答案：A
解析：本题考查的是含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最后调用派生类自己的构造函数。第7题：
下列程序的运行结果是 includeclass A { int a; public: A( ) {a=0;}A(int aa) { 下列程序的运行结果是
#include＜iostream.h＞
class A
{
int a;
public:
A( ) {a＝0;}
A(int aa)
{
a＝aa;
cout ＜ ＜ a＋＋;
}
};
void main( )
A x,y(2) ,z(3) ;
cout ＜ ＜ endl;
}
A．00
B．23
C．34
D．25
正确答案：B
解析：本题考查的是对构造函数的掌握，另外“＋＋”运算符是右结合的，所以在进行输出的时候都是先把原来的输出后再自加1。第8题：
下列程序的运行结果是()。 includeclass A { inta; public: A(){a=0:} A(int aa) { 下列程序的运行结果是( )。 #include＜iostream.h＞ class A { inta； public： A(){a=0:} A(int aa) { a=aa； cout＜＜a++； } }； void main() { A x，y(2)，z(3)； cout＜＜endl； }
A．0
B．23
C．34
D．25
正确答案：B
第9题：
以下程序执行结果是 ( )。includeclass Base{public virtual void fun() {cout<<"B 以下程序执行结果是 ( )。 #include ＜iostream.h＞ class Base { public virtual void fun() { cout＜＜"B"; } }; class Derived { public: Derived() { cout＜＜"D"; } virtual void fun(){ Base::fun(); cout＜＜"C"; } } int main () { Base *ptr; Derived obj; ptr=&obj; p-＞fun ( ); return 0; }
A．DBC
B．DCB
C．BDC
D．CBD
正确答案：A
解析：本题考核虚函数的应用。主函数中创建派生类Derived的对象。obj时，调用其构造函数首先输出字符'D'。然后调用fun()函数，由于派生Derived已对基类的虚函数fun()进行了重定义，所以语句“p-＞fun()；”调用的是派生类中的函数fun()，即输出BC。所以答案为A选项。第10题：
下面程序的结果是includeclass A{int a;public:A( ):a(1){}void showa( ){cout< 下面程序的结果是 #include＜iostream.h＞ class A { int a； public： A( ):a(1){} void showa( ){cout＜＜a；} }； class B { int a； public： B( ) ：a(2) {}
A．1
B．2
C．3
D．程序有错误
正确答案：C
解析：类A，类B，中都有showa()函数，类C继承后再次重写showa()函数就解决了继承的二义性，这时c.showa()函数显示的就是类C中的showa()的值。第11题：
下面程序的结果是()。includeclass A{int a;public:A():a(1){}void showa(){cout< 下面程序的结果是( )。 #include＜iostream.h＞ class A { int a； public： A()：a(1){} void showa(){cout＜＜a；} }； Class B { int a； public： B()：a(2){} void showa(){cout＜＜a；} )； class C：public A，public B { int a； pu
A．1
B．2
C．3
D．程序有错误
正确答案：C
解析： 类A，类B，中都有showa()函数，类C继承后再次重写showa()函数就解决了继承的二义性，这时c, showa()函数显示的就是类C中的showa()的值。第12题：
下列程序的运行结果是______。 includeclass Base { public: virtual void func(int 下列程序的运行结果是______。
include＜iostream.h＞
class Base
{
public:
virtual void func(int i){cout＜＜"class Base:"＜＜i＜＜end1;)
};
class Derived: public Base
{
public:
void func(double d){cout＜＜"class Derived:"＜＜d＜＜endl;}
};
void main( )
{
Base a,*p=a;
Derived b;
p=&b;
(*p).func(3.3);
}
正确答案：class Base:3
class Base:3 解析：题中基类和派生类中有同名函数，但是参数不同。派生关系中，只有在函数类型、函数名和参数个数、参数类型完全相同时，才表现多态性。本题中参数不同，编译器便认为是两个完全不同的函数。通过基类的指针指向派生类对象时，该指针只能访问到派生类中具有多态性的成员函数，而与基类无关的函数是无法通过基类指针来访问的。故调用的是base类的 func函数，系统将3.3强制转化为整型数3。如果将派生类中的func的形参改为int型，则执行的就会是派生类的func函数，此时表现为多态。第13题：
下面程序的运行结果是()。includeclass base{protected:int a;public:base(){cout<< 下面程序的运行结果是( )。 #include＜iostream.h＞ class base{ protected： int a； public： base(){cout＜＜“0”；} }； Class basel：Virtual base{ public： basel(){cout＜＜“1”；} }； Class base2：virtual base{ public： base2(){cout＜＜“2”；)
A．0123
B．3120
C．0312
D．3012
正确答案：A
解析： 本题考查的是含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最后调用派生类自己的构造函数。第14题：
下面程序的运算结果是()。includeusing namespace std;class A{public:virtual void f 下面程序的运算结果是( )。 #include＜iostream＞ using namespace std; class A { public: virtual void fun()=0; }; class B:public A } public: void fun() {cout＜＜"new file"＜＜" ";} }; class C:public A { public： void fun() { cout＜＜"open file"＜＜" ";} }; void main() { A a, * p; B b;C c; p=&c; p-＞fun(); p=&b; }
A．new file open file
B．new file new file
C．编译出错
D．open file new file
正确答案：C
解析：语句Aa,*p；用抽象类说明了一个对象，这是不允许的。若把其改为A*p；则程序运行结果为D。第15题：
若有以下程序:includeusing namespace std;class Base{public: Base ( ) {x=0; } in 若有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base ( ) { x=0; } int x; }; class Derivedl : virtual public Base { public: Derivedl () { x=10; } }; class Derived2 : virtual public Base { public: Derived2 () { x=20; } }; class Derived : public Derivedl,protected Derived2{ }; int main ( ) { Derived obj; cout＜＜obj .x＜＜end1; return 0; } 该程序运行后的输出结果是 ( )。
A．20
B．30
C．10
D．0
正确答案：A
解析：本题中，虽然Derivedl和Derived2都是由共同的基类x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数，使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第16题：
下面程序的结果是includeclass A{int a;public:A( ) :a(1) {}void showa ( ) {cout 下面程序的结果是 #include＜iostream.h＞ class A { int a; public: A( ) :a(1) {} void showa ( ) {cout ＜ ＜ a;} }; class B { int a; public: B( ) :a(2) {} void showa( ) {cout ＜ ＜ a;} }; class C: public A, public B { t a; public: C( ) :a(3) {} void showa( ) {cout ＜ ＜ a;} }; void main( ) { C c; c.showa( ) ; }
A．1
B．2
C．3
D．程序有错误
正确答案：C
解析：类A、类B中都有showa( ) 函数，类C继承后再次重写showa( ) 函数就解决了继承的二义性，这时c. showa( ) 函数显示的就是类C中的showa ( ) 的值。第17题：
下面程序的输出结果是【】。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的构造函数。第18题：
以下程序的执行结果是______。 includeclass base { public: virtual void who(){c 以下程序的执行结果是______。
include＜iostream.h＞
class base
{
public：
virtual void who(){cout＜＜"base class"＜＜endl：}
}；
class derrvel:public base
{
public：
void who(){cout＜＜"derivel class"＜＜endl：}
};
class derive2；public base
{
public：
void who() {cout＜＜"derive2 class"＜＜endl；}
}；
void main()
{
base obj1，*P；
derive1 obj2；
derive2 obj3：
p=&obj1；
p-＞who()；
p=&obj2：
p-＞who()；
p=&obj3；
p-＞who()；
}
正确答案：base class derivel class derive2 class
base class derivel class derive2 class第19题：
若有以下程序:includeusing namespace std; class Base public: Base() { x=0;} in 若有以下程序： #include ＜iostream＞ using namespace std; class Base public: Base() { x=0; } int x; }; class Derivedl: virtual public Base public: Derived1() { x=10; } }; class Derived2: virtual public Base publici Derived2() x=20; }; class Derived :public Derived1,protected Derived2 {}; int main() Derived obj; cout＜＜obj.x＜＜end1; return 0; } 该程序运行后的输出结果是
A．20
B．30
C．10
D．0
正确答案：A
解析：本题考核虚基类的应用。本题中，虽然Derived1和Derived2都是由共同的基类x派生而来的，但山于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第20题：
有如下程序: includeclass x { protected: int a; public:x(){ a=1;} }; class x 有如下程序： #include ＜iostream.h＞ class x { protected: int a; public: x() { a=1; } }; class x1 : virtual public x { public: x1() { a+=1; cout＜＜a; } }; class x2 : virtual public x { public: x2() { a+=2; cout＜＜a; } }; class y : public xl,public x2 { public: y() { cout＜＜a＜＜end1; } }; int main() { y obj; return O; } 该程序运行后的输出结果是( )。
A．1
B．123
C．242
D．244
正确答案：D
解析：本题程序中引入了虚基类。在主函数main中，执行语句“yobj；”时，先执行虚基类x的构造函数，使a=1；然后执行类x1的构造函数，使a=2，并输出值2；再执行类x2的构造函数，使a=4，并输出值4；最后执行类y的构造函数，输出值4。第21题：
下面程序的结果是includeclass A { int a;public: A():a(1){} void showa(){cout<< 下面程序的结果是 #include＜iostream．h＞ class A { int a； public： A()：a(1){} void showa(){cout＜＜a；} }； class B { int a； public： B()：a(2){} void showa(){cout＜＜a；} }； class C：public A，public B { int a； public： C()：a(3) ㈠ voidshowa(){cout＜＜a；} }； voidmain() { C c； c．showa()； }
A．1
B．2
C．3
D．程序有错误
正确答案：C
解析：类A，类B，中都有showa()函数，类C继承后再次重写showa()函数就解决了继承的二义性，这时c．showa()函数显示的就是类C中的showa()的值。第22题：
若有以下程序: includeusing namespace std;class Base{public:Base ( ){x=0;}int x 若有以下程序：# include ＜iostream＞using namespace std;class Base{public: Base ( ) { x=0; } int x;};class Derived1 : virtual public Base{public: Derived1 ( ) { x=10; }}; class Derived2 : virtual public Base{public: Derived2 () { x=20; }};class Derived : public Derived1,protected Derived2{ };int main(){ Derived obj; cout＜＜obj.x＜＜end1; return 0;} 该程序运行后的输出结果是
A．10
B．20
C．30
D．0
正确答案：B
解析：本题考核虚基类。本题中，虽然Derived1和Derived2都是由共同的基类 x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obj”时，就会先调用虚基类 Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第23题：
下面程序的运行结果是includeclass base{protected: int a;public: base(){cout << 下面程序的运行结果是 #include＜iostream．h＞ class base{ protected： int a； public: base(){cout ＜＜"0"；} }； class basel：virtual base{ public： basel () {cout ＜＜"1"；} }； class base2：virtual base{ public： base2(){cout ＜＜"2"；} }； class derived：public basel，public base2{ public： derived(){cout ＜＜"3"；} }； void main() { derived obj； cout ＜＜end1； }
A．123
B．3120
C．312
D．3012
正确答案：A
解析：本题考查的是含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最后调用派生类自己的构造函数。