有如下程序#includeusing namespace std;class A{public:virtual Void funcl（）{cout<< “A1”;}void fune2（）{cout<< “A2”;}};class B: public A{public:void func1（）{cout<< “B1”;}void func2（）{cout<< “B2”;}};Int main（）{A*p=new B;p->funcl（）;p->func2（）;retum0;}运行程序，屏幕上将显示输出__
题目
有如下程序
#include
using namespace std;
class A{
public:
virtual Void funcl（）{cout<< “A1”;}
void fune2（）{cout<< “A2”;}
};
class B: public A{
public:
void func1（）{cout<< “B1”;}
void func2（）{cout<< “B2”;}
};
Int main（）{
A*p=new B;
p->funcl（）;
p->func2（）;
retum0;
}
运行程序，屏幕上将显示输出______。
A．B1B2
B．A1A2
C．B1A2
D．A1B2
相似考题
参考答案和解析
更多“有如下程序#includeusing namespace std;class A{public:virtual Void funcl（）{cout “A1”;}void fune2（）{cout “A2”;}};class B: public A{public:void func1（）{cout “B1”;}void func2（）{cout “B2”;}};Int main（）{A*p=new B;p-funcl（）;p-func2（）;retum0;}运行程序，屏幕上将显示输出______。A．B1B”相关问题
-
第1题：
有如下程序:includeusing namespace std;class XX{protected:int k;public:XX(int n= 有如下程序： #include＜iostream＞ using namespace std; class XX { protected: int k; public: XX(int n=5):k(n){}; ～XX() { cout＜＜"XX": } virtual void f()const=0; }; inline void XX::f()const { cout＜＜k+3; }; class YY:public XX { public: ～YY() { cout＜＜”YY”; } void f()const { cout＜＜k-3; XX::f(); } }; int main() { XX &p=*new YY; P.f(); delete &p; return 0: } 执行上面的程序将输出( )。
A．28XX
B．28YYXX
C．33XX
D．33XXYY
正确答案：A
解析：类YY公有派生于类XX，派生类对象可以替代基类对象向基类埘象的引用进行赋值初始化，XX&p=*new YY语句定义了XX对象p引用，并用YY对象初始化，p并不是YY对象的别名，是XX基类对象的别名，故先调用基类XX的构造函数将k初始化为5，p.f()首先输出k-3即2，然后调用XX::f()输出k+3，即8，delete &p删除p，调用XX的析构函数输出“XX”。 -
第2题：
有如下程序:includeusing namespace std;Class Base{public:Base(){cout<<“BB”;f() 有如下程序： #include＜iostream.h＞ using namespace std； Class Base { public： Base(){cout＜＜“BB”；f()；} void{(){cout＜＜“BF”；} }； class Derived：public Base { public： Derived(){cout＜＜“DD”；} void f(){cout＜＜“Df”；) }； int main
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析： 本趣考查的是类的继承和派生。派生类执行构造函数的一般次序为；首先调用基类构造函数，然后调用成员对象的构造函数，最后是派生类构造函数中的内容。题目中定义派生类对象d时，先调用基类Base的构造函数，输出BBBf，然后调用派生类Derived的构造函数，输出DD。 -
第3题：
有如下程序: includeusing namespace std; class ONE { public: virtual void f() { 有如下程序：
include ＜iostream＞
using namespace std;
class ONE
{
public:
virtual void f() { cout ＜＜ "1"; }
};
class TWO: public ONE
{
public:
TWO() { cout ＜＜ "2"; }
};
class THREE: public TWO
{
public:
virtual void f() {TWO::f(); cout ＜＜ "3"; }
};
int main()
{
ONE aa, *p;
TWO bb;
THREE cc;
p=&cc;
P-＞f();
return 0;
}
执行上面程序的输出是【 】。
正确答案：2213
2213 -
第4题：
有如下程序includeusing namespace std;class A{public:virtual void func1 (){ cou 有如下程序#include ＜iostream＞using namespace std;class A{public:virtual void func1 (){ cout＜＜"A1"; }void func2(){ cout＜＜"A2"; }};class B: public A{public:void func l(){ cout＜＜"B1"; }void func2(){ cout＜＜"B2"; }};int main() {A *p=new B;p-＞func1();p-＞func2();return 0;}运行此程序，屏幕上将显示输出( )。
A．B1B2
B．A1A2
C．B1A2
D．A1B2
正确答案：C
-
第5题：
有如下程序: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第6题：
下面程序的运算结果是()。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。第7题：
有如下程序： #inClude<iostream> using namespaCe std； Class Base{ publiC： void output{Cout<<1；} virtual void Print{Cout<<B’；} }； Class Derived：publiC Base{ publiC： void output{Cout<<2；} void Print{Cout<<’D ；} }； int main { Base * ptr=new Derived； ptr一>output； ptr一>Print； delete ptr； retum0； } 执行这个程序的输出结果是( )。
A.1B
B.lD
C.2B
D.2D
正确答案：B
在某基类中声明为vitua1并在一个或多个派生类中被重新定义的成员函数，本题中定义了一个指向派生类对象的基类指针ptr，执行ptr一>outpnt后，会执行基类的output函数，输出1，由于Print是虚函数，所以ptr->Print会执行派生类的Print，即输出D，所以本题答案为B。第8题：
有如下程序:includeusing namespace std;class A{public:virtual void func1(){cout< 有如下程序： #include＜iostream＞ using namespace std; class A{ public: virtual void func1(){cout＜＜"A1";} void func2(){cout＜＜"A2";} }; class B:public A{ public: void func1(){cout＜＜"B1";} void func2(){cout＜＜"B2";} }; int main() { A *p=new B; p-＞func1(); p-＞func2(); return 0; } 执行该程序，屏幕上将显示输出( )。
A．B1B2
B．A1A2
C．B1A2
D．A1B2
正确答案：C
解析：程序中B为A的派生类，由主函数入手，主函数中定义了类A的指针p指向类B。根据基类中的“virtualvoidfunc1()”知道A中的func1为虚函数，执行“p-＞func1()；”语句，通过指针变量调用此虚函数，此时调用的就是指针变量指向的同名函数，即派生类的func1函数，输出B1。而fun2不是虚函数，所以执行“p-＞func2();”输出为A2。第9题：
有以下程序:includeusing namespace std;class A{public: virtual void show() {cout 有以下程序：
include ＜iostream＞
using namespace std;
class A
{
public:
virtual void show()
{
cout＜＜"A";
}
};
class B : public A
{
public:
void show()
{
cout ＜＜ "B";
}
};
void display( A * obj )
{
obj-＞ show();
}
int main ( )
{
A demol;
B demo2;
display( & demol );
display( & demo2 );
return 0;
}
执行后的输出结果为【 】。
正确答案：AB
AB 解析：本题考核赋值兼容原则以及派生与继承的应用。题中函数display()形参类型为类A，执行语句“display(&demo1)；”则输出A。执行语句“display(&dem02)；”时，由于show()函数为虚函数，所以调用类B中show()函数，输出B。所以最后结果为AB。第10题：
有下列程序:inCludeusing namespace std;c1ass A{pubic:virmal void func1(){cout<<" 有下列程序： #inClude＜iostream＞ using namespace std; c1ass A{ pubic: virmal void func1(){cout＜＜"A1";} void func2(){cout＜＜"A2";} }; c1ass B:public A{ publIc: void func1(){cout＜＜"B1";} void func2(){cout＜＜"B2"
A．B182
B．A1A2
C．B1A2
D．A182
正确答案：C
解析： 程序中B为A的派生类，由主函数入手，主函数中定义了类A的指针p指向类B。根据基类中的“virtual void func1()”知道A中的func1为虚函数，执行“p-＞func1()；”语句，通过指针变量调用此虚函数，此时调用的就是指针变量指向的同名函数，即派生类的func1函数，输出B1。而fun2不是虚函数，所以执行“p-＞func2()；”输出为A2。第11题：
若有如下程序:includeusing namespace std;class TestClass{public:void who() {cout 若有如下程序： #include＜iostream＞ using namespace std; class TestClass { public: void who() {cout＜＜"TestClass"＜＜endl;} }; class TestClass1:public TestClass { public: void who(){cout＜＜"TestClass1"＜＜endl;} }; int main() { TestClass *p; TcstClass1 obj1; p=&obj1; p-＞who(); return 0; } 则该程序运行后的输出结果是( )。
A．TestClass1
B．TestClass
C．0
D．无输出
正确答案：A
解析：程序中的TestClas1为TestClass的派生类，主函数main中定义TestClass对象*p，TestClass1对象obj1，然后p引用obj1，执行p-＞who()则是调用基类中的who函数，输出TcstClass。第12题：
有如下程序： #include<iostream> using namespace std； class A{ public： virtual void fancl{cout<<”Al”；} void func2{cout<<”A2”；} }； class B：public A{ public： void funcI{tout<<”Bl”；} void func2{tout<<”B2”；} }； intmain} A*P=new B： P—>funcl； P—>func2； delete p； return 0； } 执行这个程序的输出结果是（ ）。
A.B182
B.A1A2
C.B1A2
D.AIB2
正确答案：C
本题考查虚函数。虚函数指在基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数。题中定义了一个派生类对象8，并使用类A的对象指针指向B，由于基类A中的funcl为虚函数，所以会执行派生类的funcl，输出Bl，而基类中的func2不是虚函数，所以P->func2会执行基类的func2，输出A2。故答案为c。第13题：
有如下程序:includeusing namespace std;classA{public:virtua1 voidfunc1(){cout<<“ 有如下程序： #include＜iostream＞ using namespace std； classA{ public： virtua1 voidfunc1(){cout＜＜“A1”；} voidfunc2(){cout＜＜“A2”；}}； class B：publicA{ public： void funcl(){cout＜＜“B1”；} void func2(){cout＜＜“B2”；}}； intmain(){ A*p＝ne
A．B1B2
B．A1A2
C．B1A2
D．A1B2
正确答案：C
解析： 程序中B为A的派生类，由主函数入手，主函数中定义了类A的指针p指向类B。根据基类中的“vir- tual void funcl()”知道A中的funcl为虚函数，执行“p-＞funcl()；”语句，通过指针变量调用此虚函数，此时调用的就是指针变量指向的同名函数，即派生类的funcl函数，输出B1。而fun2不是虚函数，所以执行“p-＞rune2()；”输出为A2。第14题：
若有如下程序:includeusing namespace std;class TestClass{public:void who(){cout< 若有如下程序： #include＜iostream＞ using namespace std； class TestClass { public： void who(){cout＜＜“TestClass”＜＜endl；} }； class TestClassl：public TestClass { public： void who(){cout＜＜“TestClassl”＜＜endl； int main() { TestC
A．TestClassl
B．TestClass
C．0
D．无输出
正确答案：A
解析： 程序中的TestClass1为TestClass的派生类，主函数main中定义TestClass对象*p，TestClass1对象obj1，然后p引用obj1，执行p-＞who()则是调用基类中的who函数，输出TestClass。第15题：
有如下程序: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
第16题：
如下程序的输出是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
解析：当创建派生类对象时，首先调用基类的构造函数，最后调用派生类的构造函数。第17题：
有如下程序:includeusing namespace std;class B{public:virtual void show( ){cout< 有如下程序： #include＜iostream＞ using namespace std； class B{ public： virtual void show( ){cout＜＜"B"；} }； class D：public B{ public： void show( ){cout＜＜"D"；} }； void funl(B*ptr){ptr-＞show( )；} void fun2(B&ref)；ref.show( )；} void fun3(B b){b.show( )；} int nlain( ){ B b，*P=Dew D； D d； funl(p)； fun2(b)； fun3(d)； return 0； } 程序的输出结果是
A．BBB
B．BBD
C．DBB
D．DBD
正确答案：C
解析：基类指针可以指向派生类对象，在对象作为参数传递时，是通过“传值调用”传递给函数的，是单向传递。使用对象指针对函数参数进行传递时，是通过“传址调用”传递给函数的，即函数的形参对象和实参对象指针变量指向同一内存地址；使用对象引用作为函数参数时，也是通过“传址调用”传递给函数的。funl(p)传递的是类D对象的地址，所以调用类D的是show( )，fun2(b)调用的和传递的都是类B的对象引用，所以调用类B的show( )。调用’fun3(d)时，由于void fun3(B b)传递的虽然是D类对象，但是形参是B类对象，所以调用基类B的show( )。第18题：
有如下程序:includeusing namespace std;class TestClass1{public:virtual void fun( 有如下程序： #include＜iostream＞ using namespace std; class TestClass1 { public: virtual void fun(){cout＜＜"1";} }; class TestClass2: public TestClass1 { public: TestClass2(){cout＜＜"2";} }; class TestClass3:public TestClass2 { public: virtual void fun(){TestClass2::fun();cout＜＜"3";} }; int main() { TestClass 1 aa,*p; TestClass2 bb; TestClass3 cc; p=&cc; P-＞fun(); return 0; } 执行上面程序的输出是( )。
A．1122
B．2112
C．2213
D．2223
正确答案：C
解析：主函数中定义TestClass1的对象aa，*p对象指针，TestClass2的对象bb以及TestClass3的对象cc。p指向cc，TestClass3为TestClass2的派生类，构造函数输出2。TestClass3中fun函数中为TestClass2中的。fun，调用TestClass2的构造函数，输出2。“p-＞fun();”，TestClass2继承于TestClass1中的fun，所以输出1。然后输出TestClass3中的“cout”3””，即输出3。第19题：
有如下程序: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。第20题：
有下列程序:includeusing namespace std;class ONE{ public:virtual void f(){COUt<<" 有下列程序：
include＜iostream＞
using namespace std;
class ONE
{
public:
virtual void f(){COUt＜＜"1";}
};
c1assTWO:public ONE
{
public:
TWO(){cout＜＜"2";}
};
class THREE:public TWO
{
pub
正确答案：2213
2213 解析： 此题考查的是派生类的构造和析构函数。建立TWO的对象bb时，调用TWO的构造函数，输出“2”；THREE类又派生于TWO类，所以建立THREE类的对象cc时又会输出“2”；ONE类的对象指针p指向了THREE类的ONE类的虚函数f()，输出“1”；最后调用THREE类的f()，输出“3”。故最终的输出结果是2213。第21题：
有如下程序: inCludeusing namespace std; class AA { public: viltual void f() { c 有如下程序：
inClude＜iostream＞
using namespace std；
class AA
{
public：
viltual void f()
{
cout＜＜"AA"；
}
}；
class BB：public AA
{
public：
BB()
{
cout＜＜"BB"；
}
}；
class CC：public BB
{
public：
virtual void f()
{
BB::f()；
cout＜＜"CC"；
}
}；
int main()
{
AA aa,*p；BB bb；CC cc；
p=&cc；
p-＞f()；
return 0；
}
运行后的输出结果【 】。
正确答案：BBBBAACC
BBBBAACC 解析：本题考核虚函数。本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。最后执行语句“p=&cc；p-＞f()；”，输出AA和CC。第22题：
有如下程序:includeusing namespace std;class B{public:Virtual void show(){cout<< 有如下程序： #include＜iostream＞ using namespace std； class B{ public： Virtual void show(){cout＜＜“B”；} }； class D：publicB{ public： void show(){cout＜＜“D”；} }； void funl(B*ptr){ptr-＞show()；} void{un2(B&ref){ref.show()；} void
A．BBB
B．BBD
C．DBB
D．DBD
正确答案：C
解析： 本题考查的知识点是，虚函数与多态性。在成员函数声明的前面加上virtual修饰，即把该函数声明为虚函数。在C++中，一个基类指针(或引用)可以用于指向它的派生类对象，而且通过这样的指针(或引用)调用虚函数时，被调用的是该指针(或引用)实际所指向的对象类的那个重定义版本。故本题最终输出结果为DBB。第23题：
有如下程序:includeusing namespace std;class Base{public:virtual void func1(){co 有如下程序: #include＜iostream＞ using namespace std; class Base{ public: virtual void func1(){cout＜＜"Base 1";} void rune2(){cout＜＜"Base 2";} }; class Derived:public Base{ public: void func1(){cout＜＜"Derived 1";} void func2(){cout＜＜"Derived 2";} }; int main(){ Base *p=new Derived; P-＞func1(); P-＞func2(); return 0: } 运行此程序,屏幕上将显示输出______。
A．Derived 1 Base 2
B．Base 1 Base 2
C．Derived 1 Derived 2
D．Base 1 Derived 2
正确答案：A
解析：派生类Derived由基类Base公有继承而来。调用p-＞func1()；后，执行派生类Derived的函数void func1()；调用p-＞rune2()；后，执行基类的函数void func2()，因为虚拟函数是根据对象的实际类型调用，非虚拟函数是根据指针类型调用。故通过指针p调用func2时将直接调用基类中的void func2()。