史上最详细C++虚继承面试必考总结

参考：
参考1
参考2

前言

本文参考了网上资料，总结了菱形继承中运用虚继承解决的原因以及虚基类成员可见性的情况。此外还详细讲述了虚函数调用的底层原理。

菱形继承

• A 派生出类 B 和类 C，类 D 继承自类 B 和类 C，这个时候类 A 中的成员变量和成员函数继承到类 D 中变成了两份，一份来自 A–>B–>D 这条路径，另一份来自 A–>C–>D 这条路径。

• 在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突。假如类 A 有一个成员变量 a，那么在类 D 中直接访问 a 就会产生歧义，编译器不知道它究竟来自 A -->B–>D 这条路径，还是来自 A–>C–>D 这条路径。

菱形继承案例（有歧义m_a）

下面是菱形继承的具体实现：

//间接基类A
class A{
protected:
    int m_a;
};

//直接基类B
class B: public A{
protected:
    int m_b;
};

//直接基类C
class C: public A{
protected:
    int m_c;
};

//派生类D
class D: public B, public C{
public:
    void seta(int a){ m_a = a; }  //命名冲突
    void setb(int b){ m_b = b; }  //正确
    void setc(int c){ m_c = c; }  //正确
    void setd(int d){ m_d = d; }  //正确
private:
    int m_d;
};

int main(){
    D d;
    return 0;
}

消除变量m_a歧义的方法（两种）

1. 为了消除歧义，我们可以在 m_a 的前面指明它具体来自哪个类：
   void seta(int a){ B::m_a = a; }
2. 虚继承（Virtual Inheritance）

菱形继承（无歧义m_a）

• 使用虚继承重新实现了上图所示的菱形继承，这样在派生类 D 中就只保留了一份成员变量 m_a，直接访问就不会再有歧义了。

//间接基类A
class A{
protected:
    int m_a;
};

//直接基类B
class B: virtual public A{  //虚继承
protected:
    int m_b;
};

//直接基类C
class C: virtual public A{  //虚继承
protected:
    int m_c;
};

//派生类D
class D: public B, public C{
public:
    void seta(int a){ m_a = a; }  //正确
    void setb(int b){ m_b = b; }  //正确
    void setc(int c){ m_c = c; }  //正确
    void setd(int d){ m_d = d; }  //正确
private:
    int m_d;
};

int main(){
    D d;
    return 0;
}

虚基类成员的可见性

因为在虚继承的最终派生类中只保留了一份虚基类的成员，所以该成员可以被直接访问，不会产生二义性。此外，如果虚基类的成员只被一条派生路径覆盖，那么仍然可以直接访问这个被覆盖的成员。但是如果该成员被两条或多条路径覆盖了，那就不能直接访问了，此时必须指明该成员属于哪个类。（不懂就看下面举例）

以图2中的菱形继承为例，假设 A 定义了一个名为 x 的成员变量，当我们在 D 中直接访问 x 时，会有三种可能性：
如果 B 和 C 中都没有 x 的定义，那么 x 将被解析为 A 的成员，此时不存在二义性。
如果 B 或 C 其中的一个类定义了 x，也不会有二义性 ，因为优先级：C中x或B中x > A中x。
如果 B 和 C 中都定义了 x，那么D直接访问 x 也将产生二义性问题，（B、C是虚继承A 的情况下）。

虚函数调用原理

#include<iostream>
using namespace std;
class A{//虚函数示例代码
    public:
        virtual void fun(){cout<<1<<endl;}
        virtual void fun2(){cout<<2<<endl;}
};
class B : public A{
    public:
        void fun(){cout<<3<<endl;}
        void fun2(){cout<<4<<endl;}
};

int main()
{
    void(*fun)(A*);
    A *p=new B;
    long lVptrAddr;
    memcpy(&lVptrAddr,p,4);
    memcpy(&fun,reinterpret_cast<long*>(lVptrAddr),4);
    fun(p);
    delete p;
    system("pause");
    return 0;
}

A* p=new B; new B是向内存（内存分5个区：全局名字空间，自由存储区，寄存器，代码空间，栈）自由存储区申请一个内存单元的地址然后隐式地保存在一个指针中.然后把这个地址赋值给A类型的指针p。

long lVptrAddr; 这个long类型的变量用来保存vptr的值。

memcpy(&lVptrAddr,p,4); 前面说了，他们的实例对象里只有vptr指针，所以我们就放心大胆地把p所指的4bytes内存里的东西复制到lVptrAddr中，所以复制出来的4bytes内容就是vptr的值，即vtbl的地址。
现在有了vtbl的地址了，那么我们现在就取出vtbl第一个slot里的内容。

memcpy(&fun,reinterpret_cast(lVptrAddr),4); 取出vtbl第一个slot里的内容，并存放在函数指针fun里。需要注意的是lVptrAddr里面是vtbl的地址，但lVptrAddr不是指针，所以我们要把它先转变成指针类型 , 这里就调用了刚才取出的函数地址里的函数，也就是调用了B::fun（）这个函数。类成员函数调用时，会有个this指针，这个p就是那个this指针，只是在一般的调用中编译器自动帮你处理了而已，而在这里则需要自己处理。

如果调用B::fun2（）怎么办，那就取出vtbl的第二个slot里的值就行了。
memcpy(&fun,reinterpret_cast(lVptrAddr+4),4); 为什么是加4呢？因为一个指针的长度是4bytes(32位机上4bytes，64位长度8bytes)。

派生类B的对象的内存布局是怎样的呢，前四个字节依然存放虚表指针，虚表中首先存放父类的虚函数地址，注意，由于派生类中也可能有①自己的虚函数，同时派生类也可以②重写父类的虚函数，虚函数表的分布如何：

- 对于情况一而言，将派生类新增加的虚函数地址依次添加到虚表（虚表中已经有父类的虚函数地址）的后面。

- 对于情况二而言，如果派生类重写了父类的虚函数，则将重写后的虚函数地址替换掉父类原来的虚函数地址，如果没有重写，则按照父类的虚表顺序存放虚函数地址

接下来的内存中依次存放该对象的父类的数据成员（非静态的数据成员），然后再存放派生类自己的数据成员。（还有内存对齐的问题）

虚继承内存布局