继承与多态常见面试题

1. 下面哪种面向对象的方法可以让你变得富有( )

A: 继承 B: 封装 C: 多态 D: 抽象

2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关， 而对方法的调用则可以关联于具体的对象。

A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

3. 面向对象设计中的继承和组合，下面说法错误的是？（）

A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复 用，也称为白盒复用

B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动 态复用，也称为黑盒复用

C：优先使用继承，而不是组合，是面向对象设计的第二原则

D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封 装性的表现

4. 以下关于纯虚函数的说法,正确的是( )

A：声明纯虚函数的类不能实例化对象

B ：声明纯虚函数的类是虚基类

C：子类必须实现基类的纯虚函数

D ：纯虚函数必须是空函数

5. 关于虚函数的描述正确的是( )

A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型

B：内联函数不能是虚函数

C：派生类必须重新定义基类的虚函数

D：虚函数可以是一个static型的函数

6. 关于虚表说法正确的是（ ）

A：一个类只能有一张虚表

B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表

C：虚表是在运行期间动态生成的

D：一个类的不同对象共享该类的虚表

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ ）

A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址

B：A类对象和B类对象前4个字节存储的都是虚基表的地址

C：A类对象和B类对象前4个字节存储的虚表地址相同

D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

8. 下面程序输出结果是什么? （）

A：class A class B class C class D

B：class D class B class C class A

C：class D class C class B class A

D：class A class C class B class D

#include<iostream>
using namespace std;
 class A{
 public:
 A(char *s) { cout<<s<<endl; }
 ~A(){}
 };
 class B:virtual public A
 {
 public:
 B(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
 };
 class C:virtual public A
 {
 public:
 C(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
 };
 class D:public B,public C
 {
 public:
 D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1)
 { cout<<s4<<endl;}
 };
 int main() {
 D *p=new D("class A","class B","class C","class D");
 delete p;
 return 0;
 }

9. 多继承中指针偏移问题？下面说法正确的是( )

A：p1 == p2 == p3

B：p1 < p2 < p3

C：p1 == p3 != p2

D：p1 != p2 != p3

 class Base1 {  public:  int _b1; };
 class Base2 {  public:  int _b2; };
 class Derive : public Base1, public Base2 { public: int _d; };
 int main(){
 Derive d;
 Base1* p1 = &d;
 Base2* p2 = &d;
 Derive* p3 = &d;
 return 0;
 }

10. 以下程序输出结果是什么（）

A: A->0

B: B->1

C: A->1

D: B->0

E: 编译出错

F: 以上都不正确

class A
   {
 public:
 virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
virtual void test(){ func();}
   };
 class B : public A
   {
 public:
 void func(int val=0){ std::cout<<"B->"<< val <<std::endl; }
   };
 int main(int argc ,char* argv[])
   {
 B*p = new B;
 p->test();
 return 0;
   }

参考答案：   1. A   2. D   3. C   4. A   5. B   6. D   7. D   8. A   9. C   10. B

问答题

1. 什么是多态？

答：参考本节课件内容

2. 什么是重载、重写(覆盖)、重定义(隐藏)？

答：参考本节课件内容

3. 多态的实现原理？

答：参考本节课件内容

4. inline函数可以是虚函数吗？

答：可以，不过编译器就忽略inline属性，这个函数就不再是 inline，因为虚函数要放到虚表中去。

5. 静态成员可以是虚函数吗？

答：不能，因为静态成员函数没有this指针，使用类型::成员函数 的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

6. 构造函数可以是虚函数吗？

答：不能，因为对象中的虚函数表指针是在构造函数初始化列表 阶段才初始化的。

7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

答：可以，并且最好把基类的析 构函数定义成虚函数。参考本节课件内容

8. 对象访问普通函数快还是虚函数更快？

答：首先如果是普通对象，是一样快的。如果是指针 对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函 数表中去查找。

9. 虚函数表是在什么阶段生成的，存在哪的？

答：虚函数表是在编译阶段就生成的，一般情况 下存在代码段(常量区)的。

10. C++菱形继承的问题？虚继承的原理？

答：参考继承课件。注意这里不要把虚函数表和虚基 表搞混了。

11. 什么是抽象类？抽象类的作用？

答：参考（3.抽象类）。抽象类强制重写了虚函数，另外抽 象类体现出了接口继承关系。