对于类定义： class A{ public: virtual void func1( ){} void func2( ){} }; class B:public A{ public: void func1(){cout＜＜"class B func 1"＜＜end1;} virtual void func2(){cout＜＜"class B func 2"＜＜end1;} }; 下面叙述正确的是(53)。A．A∷func2()和B∷func1()都是虚函数B．A∷func2()和B∷func1()都不是

题目

对于类定义： class A{ public: virtual void func1( ){} void func2( ){} }; class B:public A{ public: void func1(){cout＜＜"class B func 1"＜＜end1;} virtual void func2(){cout＜＜"class B func 2"＜＜end1;} }; 下面叙述正确的是(53)。

A．A∷func2()和B∷func1()都是虚函数

B．A∷func2()和B∷func1()都不是虚函数

C．B∷func1()是虚函数，而A∷func2()不是虚函数

D．B∷func1()不是虚函数，而A∷func2()是虚函数

相似考题

1.下列程序执行后的输出结果是void func1（int i）;void func2（int i）;char st［］="hello,friend!";void func1（int i）{ printf（"%c",st［i］）;if（i<3）{i+=2;func2（i）;}}void func2（int i）{ printf（"%c",st［i］）;if（i<3）{i+=2;func1（i）;}}main（）{ int i=0; func1（i）; printf（"＼n"）;}A．helloB．helC．hloD．hlm

2.（ 35 ）有如下程序#includeusing 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) B1B2B) A1A2C) B1A2D) A1B2

3.对于类定义class A{public：virtual void funcl（）{}void func2（）{}};class B：public A{public：void funcl（）{cout <<"class B func 1”<virtual void func2（）{cout <<"class B func 2"<};下面正确的叙述是A．A：：func2（）和B：：funcl（）都是虚函数B．A：：func2（）和B：：funcl（）都不是虚函数C．B：：funcl（）是虚函数，而A：：func2（）不是虚函数D．B：：funcl（）不是虚函数，而A：：func2（）是虚函数

4.有如下程序#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．B1B2B．A1A2C．B1A2D．A1B2

更多“对于类定义： class A{ public: virtual void func1( ){} void func2( ){} }; class B:public A{ public: void func1(){cout＜＜"class B func 1"＜＜end1;} virtual void func2(){cout＜＜"class B func 2"＜＜end1;} }; 下面叙述正确的是(53)。A．A∷func2()和B∷func1()都是虚函数B．A∷func2()和B∷func1()都不是”相关问题

第1题：

对于类定义
class A{
public:
virtual void func1( ) {}
void func2( ) {}
};
class B: public A{
public:
void func1( ) {cout ＜＜ "class B func 1" ＜＜ endl;}
virtua1 void func2( ) {cout ＜＜ "class B func 2" ＜＜ endl;}
};
下面正确的叙述是
A．A: :func2( ) 和B: :func1( ) 都是虚函数
B．A: :func2( ) 和B: :func1( ) 都不是虚函数
C．B: :func1( ) 是虚函数，而A: :func2( ) 不是虚函数
D．B: :func1( ) 不是虚函数，而A: :func2( ) 是虚函数

正确答案：C
解析：基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中func1( ) 是虚函数;而类A中的func2没有被关键字virtual修饰，所以不是虚函数。
第2题：

对于类定义 class A{ public： void func2{} }； class B：public A{ public： w)id funcl| cout<<"class B func l”<<endl：} virtual voiIl fimc2{cout<<"class B func 2" <<endl：} }；下面正确的叙述是( )。
A.A：：rune2和B：：funcl都是虚函数
B.A：：func2和B：：funel都不是虚函数
C.B：：funcl是虚函数，而A：：func2不是虚函数
D.B：：funcl不是虚函数，而A：：func2是虚函数

正确答案：C
基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中funcl是虚函数；而类A中的func2没有被关键字virtual修饰，所以不是虚函数。
第3题：

对于类定义： class A{ public： virtual void funcl(){} void func2(){} )； class B：public A{ public： voidfuncl(){cout＜＜“class Bfunc 1”＜＜endl；} virtual void func2(){cout＜＜“class B func 2”＜＜endl；} }；下面正确的叙述是( )。
A．A：：func2()和B：：funcl()都是虚函数
B．A：：func2()和B：：funcl()都不是虚函数
C．B：：funcl()是虚函数，而A：：func2()不是虚函数
D．B：：funcl()不是虚函数，而A：：func2()是虚函数

正确答案：C
解析：基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中funcl()是虚函数；而类A中的func2没有被关键宇virtual修饰，所以不是虚函数。
第4题：

下面程序执行后的结果是()。includeusing namespace std;void func1(int i);void func

下面程序执行后的结果是( )。 #include＜iostream＞ using namespace std； void func1(int i); void func2(int i); char st[]="hello, friend!"; void func1(int i) { cout＜＜st[i]; if(i＜3){i+=2;func2(i);} } void func2(int i) { cout＜＜st[i]； if(i＜3){i+=2;func1(i);} } void main() { int i=0;func1(i);cout＜＜endl；}
A．ello
B．hel
C．hlo
D．him

正确答案：C
解析：主函数中调用func1()函数，实参赋值为0，在该函数中先输出st[0]，即“h，，；然后func1()函数又调用func2()函数，实参赋值为2，func2()函数运行时先输出st[2]，即“1”；然后又调用func1()函数，实参赋值为4，func1()函数运行时先输出st[4]，即“o”。
第5题：

下列程序写法不正确的是( )。
A．func1(){…func2(){…}…}
B．func1(){…}func2(){…}
C．func2();func1(){…func2();…}func2(){…}
D．func1(){…func1();…}

正确答案：A
解析：一个函数不能在另一个函数中定义，即不能嵌套定义。
第6题：

下面代码有何错误
void func2(int *value)
{
*value = 2;
}
void func1()
{
int *p = 0;
func2(p);
}

正确答案：
第7题：

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

对于类定义： classA{ public： virtualvoidfuncl（）{} voidfunc2（）{} }； classB：publicA{ public： voidfuncl（）{cout<<"classBfunc1"<<endl；} virtualvoidfunc2（）{cout<<"classBfunc2" <<endl；} }；下面正确的叙述是（）。
A.A：：func2（）和B：：func1（）都赵虚函数
B.A：：rune2（）和B：：func1（）都不是虚函数
C.B：：func1（）是虚函数，而A：：fune2（）不是虚函数
D.B：：func1（）不是虚函数，而A：：func2（）是虚函数

正确答案：C
C。【解析】基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中funcl是虚函数；而类A中的func2没有被关键字virtual修饰；所以不是虚函数。
第9题：

有下列程序: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。
第10题：

有如下程序: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()。
第11题：

对于类定义 class A { public： virtual void funcl(){} void func2(){} }; class D:public A{ public: void funcl(){cout＜＜ "class B rune 1"＜＜end1;} virtual void func2(){cout＜＜ "class B func 2"＜＜end1；} }; 下面正确的叙述是 ______。
A．A::func2()和B::funcl()都是虚函数
B．A::func2()和B::funcl()都不是虚函数
C．B::func1()是虚函数，而A::func2()不是虚函数
D．B::func1()不是虚函数，而A::func2()是虚函数

正确答案：C
第12题：

对于类定义： class A{ public: virtual void func1(){} Void func2 (){} }; class B:public A{ public: void func1(){cout＜＜"class B func 1"＜＜end1;} virtual void func2(){cout＜＜"class B func 2"＜＜end1;} };下面叙述正确的是（）。

A.A::func2()和B::func1()都是虚函数
B.A::func2()和B::func1()都不是虚函数
C.B::func1()是虚函数，而A::func2()不是虚函数
D.B::func1()不是虚函数，而A::func2()是虚函数

答案：C
解析：
继承是面向对象程序设计最重要的特征，指的是一个新类从已有的类那里获得其已有的特征，并可以添加新的特征。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。题中类A声明了两个函数，一个虚函数func1()和一个函数func2()，类B继承于类A，那就继承了类A的特征，因此，类B中的func1()是一个虚函数。在类B中又把func2()声明成虚函数，给func2()增加了新的特征，所以，类B中的两个函数都是虚函数，而在类A中只有func1()是虚函数。
第13题：

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

下列程序执行后的输出结果是______。
A．hello
B．hel
C．hlo
D．hlm void func1 (int i)； void func2 (int i)； char st[]="hello,friend!"； void func1(int i) { printf("%c"，st[i])； if(i＜3){ i+=2；func2(i)； } } void func2 (int i) { printf("％c"，st[i])； if(i＜3){ i+=2；func1(i)； } } main() { int i=0；func1(i)；printf("\n")；}

正确答案：C
第15题：

对于类定义 classA{ public： virtual void func1(){} void func2(){} }； Class B：public A{ public： void funcl(){cout ＜＜”class B func1” ＜＜end1；} virtual void func2(){cout ＜＜"class B func 2" ＜＜end1；} }；下面正确的叙述是
A．A∷func2()和B∷funcl()都是虚函数
B．A∷func2()和B∷funcl()都不是虚函数
C．B∷funcl()是虚函数，而A∷func2()不是虚函数
D．B∷funcl()不是虚函数，而A∷func2()是虚函数

正确答案：C
解析：基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中funcl()是虚函数；而类A中的fanc2没有被关键字virtual修饰，所以不是虚函数。
第16题：

下列程序执行后的输出结果是( )。 void func1 (int i)； void func2(int i)； char st[]="hello,friend!"； void func1 (int i) { printf("%c"，st[i])； if(i＜3){i+=2；func2(i)；} } void func2(int i) { printf("%c"，st[i])； if(i＜3){i+=2；func1(i);}
A．hello
B．hel
C．hol
D．hlm

正确答案：C
第17题：

下面代码有何错误
void func1()
{
int *pa = NULL;
func2(pa);
delete pa;
}
void func2(int *pb)
{
pb = new int(5);
}

正确答案：
第18题：

int func1(int& b)
{
return 0;
}
void func2()
{
int bbb = 3;
func1(&bbb);
func1(bbb);
}
func2中有何错误，func1的参数b 的类型是什么。

正确答案：
第19题：

有下列程序void func1(int i);void func2(int i);char st［］="hello,friend! ";void func1(int i){ printf("%c",st［i］); if(i<3){i+=2;func2(i);}}void func2(int i){ printf("%c",st［i］); if(i<3){i+=2;func1(i);}}main(){ int i=0;func1(i); printf("＼n");}执行后的输出结果是A．hello B．helC．hlo D．hlm

正确答案：C
根据变量作用域与其定义语句在程序中出现位置之间的关系，可把变量分为局部变量和全局变量两种。其中，在函数外部定义的变量叫做全局变量，又称为外部变量；在函数体内定义的变量是局部变量，又称为内部变量。全局变量的作用域是整个程序，而局部变量的作用域是定义它的函数或者程序段。
在本题中，程序首先声明两个无返回值函数func1和func2，然后定义一个全局数组st。做这类除主函数外，有其他函数的试题时，首先需要分析其他函数来得知函数的作用，然后再看主函数。
func1函数带有一个整型变量的形参，在函数体中，首先输出以形参作为下标的数组元素值，然后执行if条件判断语句，其条件为形参变量i<3。如果结果为真，则将变量i加2后保存，然后调用func2函数；如果条件结果为假，则结束该函数。
从程序中不难看出，func2函数与func1函数基本类似，只是最后它对函数func1进行调用，与前者不同，两个函数是互相调用的。
在主函数中定义一个变量i并赋值为0，然后调用函数func1，根据我们对函数func1的分析可知，输出st[0]即字符‘h’，而此时if语句的结果为真，执行i加2并调用func2函数操作。此时变量i的值为2，因此，输出st[2]即字符‘l’，此时函数func2中的if条件语句结果为真，同样执行i加2，并调用func1函数操作，然后通过func1函数输出st[4]即字符‘o’，此时由于变量i的值等于4，是大于3的，函数结束。程序运行到出口，最后输出换行。因此，本程序最终的输出结果是hlo。
第20题：

对于类定义 class A{ public： virtual void func1( ){} void func2( ){} }； class B：public A{ public： void func1( ){cout＜＜"class B func 1"＜＜ end1；} virtual void func2( ){cout ＜＜ "class B func2"＜＜ end1；} }; 下面正确的
A．A::func2( )和B::func1( )都是虚函数
B．A::func2( )和B::func1( )都不是虚函数
C．B::func1( )是虚函数，而A::func2( )不是虚函数
D．B::func1( )不是虚函数，而A::func2( )是虚函数

正确答案：C
解析：基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中funcl()是虚函数；而类A中的func2没有被关键字virtual修饰，所以不是虚函数。
第21题：

对于类定义：
classA{
public：
virtualvoidfuncl（）{}
voidfunc2（）{}
}；
classB：publicA{
public：
voidfuncl（）{cout<<"classBfunc1"<<endl；}
virtualvoidfunc2（）{cout<<"classBfunc2"
<<endl；}
}；
下面正确的叙述是（）。
A.A：：func2（）和B：：func1（）都赵虚函
B.A：：rune2（）和B：：func1（）都不是虚函数
C.B：：func1（）是虚函数，而A：：fune2（）不是虚函数
D.B：：func1（）不是虚函数，而A：：func2（）是虚函数

正确答案：C
C。【解析】基类中说明的虚函数，在派生类中自然就是虚函数，所以类B中funcl是虚函数；而类A中的func2没有被关键字virtual修饰；所以不是虚函数。
第22题：

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

下列程序的运行结果是______。 include class 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函数，此时表现为多态。

题目

相似考题

相关内容