继承和多态常见的面试问题

概念

1. 下面哪种面向对象的方法可以让你变得富有( A)
   A: 继承 B: 封装 C: 多态 D: 抽象

2. (D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，
   而对方法的调用则可以关联于具体的对象。
   A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

面向对象有三种特性：封装，继承，多态
其中多态性有两种，一种是依靠函数重载实现的静态绑定，一种是依靠虚函数实现的动态绑定。动态绑定跟对象的引用类型无关，他会根据具体的对象调用对应的方法。

3. 面向对象设计中的继承和组合，下面说法错误的是？（C）
   A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复
   用，也称为白盒复用
   B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动
   态复用，也称为黑盒复用
   C：优先使用继承，而不是组合，是面向对象设计的第二原则
   D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封
   装性的表现

优先使用对象组合，而不是类继承 。

4. 以下关于纯虚函数的说法,正确的是( A)
   A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
   C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数

纯虚函数不可以实例化出对象，声明纯虚函数的类是抽象类，如果不用子类可以不重写基类的纯虚函数，纯虚函数的函数体内可以实现，不一定必须是空函数

5. 关于虚函数的描述正确的是( B)
   A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
   C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数

A：虚函数有三同，函数名相同，返回值相同，参数相同（协变和析构函数除外），协变就是返回值可以是具有父子关系的指针或引用，而析构函数由于编译器统一识别为destructor，所以即使每个类看着析构函数的函数名不同，但是却可以实现虚函数。B：内联函数不能成为虚函数，因为内联函数会被展开没有地址，而虚函数需要地址。C：派生类可以不重新定义基类的虚函数。D：虚函数不可以是static类型，因为虚函数需要this指针调用，而static类型的函数无this指针。

6. 关于虚表说法正确的是（D ）
   A：一个类只能有一张虚表
   B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
   C：虚表是在运行期间动态生成的
   D：一个类的不同对象共享该类的虚表

A：多继承的时候可能就会有多张虚表。B：子类和基类是两个不同的对象，他们的虚表没有任何关系。 C：虚表是在编译时期生成的，而虚表指针是在构造函数的初始化列表生成的。D：一个类的不同对象用的同一张虚表是正确的。

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（D ）
   A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
   B：A类对象和B类对象前4个字节存储的都是虚基表的地址
   C：A类对象和B类对象前4个字节存储的虚表地址相同
   D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

A类对象和B类对象前4个字节存储的都是虚表的地址。
虚表存储了一个类中所有虚函数的地址。
虚基表，又称虚基类表，主要用于解决菱形继承中的数据冗余和二义性问题。虚基表存储的是偏移量，即虚基表的位置与基类那一部分内容的地址之间的距离。虚基表也是以NULL结尾的。
A类和B类是不同的类如果都有虚函数各自有各自的虚表。

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

#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;
}

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

首先这是个多继承问题，我们可以看到D类先继承B，再继承C，而B类中先继承了A，所以D中构造函数的初始化顺序为A B C D，A用s1初始化进入s1的构造函数打印class A，然后用s1和s2初始化B，由于B虚继承A只有一份A所以刚开始在A初始化一次后后面在其他类的初始化列表就不再初始化A了，所以打印S2也就是classB，然后用s1和s3初始化C，与B同理A不初始化打印S3也就是class C，最后进入D的构造函数函数体打印classD

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

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;
}

A：p1== p2== p3B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

p1和p2虽然都是其父类，但在子类内存模型中，其位置不同，所以p1和p2所指子类的位置也不相同，因此p1!=p2,由于p1对象是第一个被继承的父类类型，所有其地址与子类对象的地址p3所指位置都为子类对象的起始位置，因此p1==p3,所以C正确

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

 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;
   }

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

(1) 由于B类中没有覆盖（重写）基类中的虚函数test()，因此会调用基类A中的test()；
(2) A中test()函数中继续调用虚函数 fun()，因为虚函数执行动态绑定，p此时的动态类型（即目前所指对象的类型）为B，因此此时调用虚函数fun()时，执行的是B类中的fun()；所以先输出“B->”；
(3) 缺省参数值是静态绑定，即此时val的值使用的是基类A中的缺省参数值，其值在编译阶段已经绑定，值为1，所以输出“1”；*

virtual 函数是动态绑定，而缺省参数值却是静态绑定。 意思是你可能会 在“调用一个定义于派生类内的virtual函数”的同时，却使用基类为它所指定的缺省参数值。
结论：绝不重新定义继承而来的缺省参数值！

问答

1. 什么是多态？
   多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

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

3. 多态的实现原理？
   主要通过虚函数和指向基类的指针或引用来实现。多态允许不同的对象对同一消息做出不同的响应。
   用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。
   存在虚函数的类都有一个一维的虚函数表叫做虚表。当类中声明虚函数时，编译器会在类中生成一个虚函数表。
   类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。
   虚函数表是一个存储类成员函数指针的数据结构。
   虚函数表是由编译器自动生成与维护的。
   virtual成员函数会被编译器放入虚函数表中。
   当存在虚函数时，每个对象中都有一个指向虚函数的指针（C++编译器给父类对象，子类对象提前布局vptr指针），当进行test(parent *base)函数的时候，C++编译器不需要区分子类或者父类对象，只需要再base指针中，找到vptr指针即可）。
   vptr一般作为类对象的第一个成员。

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

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

6. 构造函数可以是虚函数吗？
   不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？可以，并且最好把基类的析
   构函数定义成虚函数。

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

9. 虚函数表是在什么阶段生成的，存在哪的？
   虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

10. C++菱形继承的问题？虚继承的原理？
    菱形继承有数据冗余和二义性的问题。
    虚继承是为了解决菱形继承中的二义性和数据冗余问题而引入的一种机制。虚继承的原理在于，通过在继承关系中引入虚基类（即在基类声明时加上virtual关键字），使得在派生类中只保留一份虚基类的子对象。这样，无论派生类通过多少条路径继承虚基类，它都只会包含一份虚基类的数据，从而避免了数据冗余。

11. 什么是抽象类？抽象类的作用？
    在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
    抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。