C++ 虚继承实现原理（虚基类表指针与虚基类表）

虚继承和虚函数是完全无相关的两个概念。

虚继承是解决C++多重继承问题的一种手段，从不同途径继承来的同一基类，会在子类中存在多份拷贝。这将存在两个问题：其一，浪费存储空间；第二，存在二义性问题，通常可以将派生类对象的地址赋值给基类对象，实现的具体方式是，将基类指针指向继承类（继承类有基类的拷贝）中的基类对象的地址，但是多重继承可能存在一个基类的多份拷贝，这就出现了二义性。

虚继承可以解决多种继承前面提到的两个问题：

虚继承底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现，每个虚继承的子类都有一个虚基类指针（占用一个指针的存储空间，4字节）和虚基类表（不占用类对象的存储空间）（需要强调的是，虚基类依旧会在子类里面存在拷贝，只是仅仅最多存在一份而已，并不是不在子类里面了）；当虚继承的子类被当做父类继承时，虚基类指针也会被继承。

实际上，vbptr指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚基类表（virtual table），虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。

在这里我们可以对比虚函数的实现原理：他们有相似之处，都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间）。

虚基类依旧存在继承类中，只占用存储空间；虚函数不占用存储空间。

虚基类表存储的是虚基类相对直接继承类的偏移；而虚函数表存储的是虚函数地址。

此篇博客有关于虚继承详细的内存分布情况

http://blog.csdn.net/xiejingfa/article/details/48028491

补充：

1、D继承了B,C也就继承了两个虚基类指针

2、虚基类表存储的是，虚基类相对直接继承类的偏移（D并非是虚基类的直接继承类，B,C才是）

1.  
   #include<iostream>
2.  
   using namespace std;
3.  
    
4.  
   class A //大小为4
5.  
   {
6.  
   public:
7.  
   int a;
8.  
   };
9.  
   class B :virtual public A //大小为12，变量a,b共8字节，虚基类表指针4
10.  
    {
11.  
    public:
12.  
    int b;
13.  
    };
14.  
    class C :virtual public A //与B一样12
15.  
    {
16.  
    public:
17.  
    int c;
18.  
    };
19.  
    class D :public B, public C //24,变量a,b,c,d共16，B的虚基类指针4，C的虚基类指针
20.  
    {
21.  
    public:
22.  
    int d;
23.  
    };
24.  
     
25.  
    int main()
26.  
    {
27.  
    A a;
28.  
    B b;
29.  
    C c;
30.  
    D d;
31.  
    cout << sizeof(a) << endl;
32.  
    cout << sizeof(b) << endl;
33.  
    cout << sizeof(c) << endl;
34.  
    cout << sizeof(d) << endl;
35.  
    system("pause");
36.  
    return 0;
37.  
    }

二： 从内存布局看C++虚继承的实现原理

准备工作

1、VS2012使用命令行选项查看对象的内存布局

微软的Visual Studio提供给用户显示C++对象在内存中的布局的选项：/d1reportSingleClassLayout。使用方法很简单，直接在[工具(T)]选项下找到“Visual Studio命令提示(C)”后点击即可。切换到cpp文件所在目录下输入如下的命令即可

c1 [filename].cpp /d1reportSingleClassLayout[className]

其中[filename].cpp就是我们想要查看的class所在的cpp文件，[className]指我们想要查看的class的类名。（下面举例说明...）

2、查看普通多继承子类的内存布局

既然我们今天讲的是虚基类和虚继承，我们就先用上面介绍的命令提示工具查看一下普通多继承子类的内存布局，可以跟后文虚继承子类的内存布局情况加以比较。

我们新建一个名叫NormalInheritance的cpp文件，输入一下内容。

1.  
   /**
2.  
   普通继承（没有使用虚基类）
3.  
   */
4.  
    
5.  
   // 基类A
6.  
   class A
7.  
   {
8.  
   public:
9.  
   int dataA;
10.  
    };
11.  
     
12.  
    class B : public A
13.  
    {
14.  
    public:
15.  
    int dataB;
16.  
    };
17.  
     
18.  
    class C : public A
19.  
    {
20.  
    public:
21.  
    int dataC;
22.  
    };
23.  
     
24.  
    class D : public B, public C
25.  
    {
26.  
    public:
27.  
    int dataD;
28.  
    };

上面是一个简单的多继承例子，我们启动Visual Studio命令提示功能，切换到NormalInheritance.cpp文件所在目录，输入一下命令：

c1  NormalInheritance.cpp /d1reportSingleClassLayoutD

我们可以看到class D的内存布局如下：

从类D的内存布局可以看到A派生出B和C，B和C中分别包含A的成员。再由B和C派生出D，此时D包含了B和C的成员。这样D中就总共出现了2个A成员。大家注意到左边的几个数字，这几个数字表明了D中各成员在D中排列的起始地址，D中的五个成员变量（B::dataA、dataB、C::dataA、dataC、dataD）各占用4个字节，sizeof(D) = 20。

为了跟后文加以比较，我们再来看看B和C的内存布局：

                 

虚继承的内存分布情况

上面我们看到了普通多继承子类的内存分布情况，下面我们进入主题，来看看典型的菱形虚继承子类的内存分布情况。

我们新建一个名叫VirtualInheritance的cpp文件，输入一下内容：

1.  
   /**
2.  
   虚继承（虚基类）
3.  
   */
4.  
    
5.  
   #include <iostream>
6.  
    
7.  
   // 基类A
8.  
   class A
9.  
   {
10.  
    public:
11.  
    int dataA;
12.  
    };
13.  
     
14.  
    class B : virtual public A
15.  
    {
16.  
    public:
17.  
    int dataB;
18.  
    };
19.  
     
20.  
    class C : virtual public A
21.  
    {
22.  
    public:
23.  
    int dataC;
24.  
    };
25.  
     
26.  
    class D : public B, public C
27.  
    {
28.  
    public:
29.  
    int dataD;
30.  
    };

VirtualInheritance.cpp和NormalInheritance.cpp的不同点在与C和C继承A时使用了virtual关键字，也就是虚继承。同样，我们看看B、C、D类的内存布局情况：

                                                                                                                                

我们可以看到，菱形继承体系中的子类在内存布局上和普通多继承体系中的子类类有很大的不一样。对于类B和C，sizeof的值变成了12，除了包含类A的成员变量dataA外还多了一个指针vbptr，类D除了继承B、C各自的成员变量dataB、dataA和自己的成员变量外，还有两个分别属于B、C的指针。

那么类D对象的内存布局就变成如下的样子：

vbptr：继承自父类B中的指针

int dataB：继承自父类B的成员变量

vbptr：继承自父类C的指针

int dataC：继承自父类C的成员变量

int dataD：D自己的成员变量

int A：继承自父类A的成员变量

显然，虚继承之所以能够实现在多重派生子类中只保存一份共有基类的拷贝，关键在于vbptr指针。那vbptr到底指的是什么？又是如何实现虚继承的呢？其实上面的类D内存布局图中已经给出答案：

实际上，vbptr指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚表（virtual table），虚表中记录了vbptr与本类的偏移地址；第二项是vbptr到共有基类元素之间的偏移量。在这个例子中，类B中的vbptr指向了虚表D::$vbtable@B@，虚表表明公共基类A的成员变量dataA距离类B开始处的位移为20，这样就找到了成员变量dataA，而虚继承也不用像普通多继承那样维持着公共基类的两份同样的拷贝，节省了存储空间。

为了进一步确定上面的想法是否正确，我们可以写一个简单的程序加以验证：

1.  
   int main()
2.  
   {
3.  
   D* d = new D;
4.  
   d->dataA = 10;
5.  
   d->dataB = 100;
6.  
   d->dataC = 1000;
7.  
   d->dataD = 10000;
8.  
    
9.  
   B* b = d; // 转化为基类B
10.  
    C* c = d; // 转化为基类C
11.  
    A* fromB = (B*) d;
12.  
    A* fromC = (C*) d;
13.  
     
14.  
    std::cout << "d address : " << d << std::endl;
15.  
    std::cout << "b address : " << b << std::endl;
16.  
    std::cout << "c address : " << c << std::endl;
17.  
    std::cout << "fromB address: " << fromB << std::endl;
18.  
    std::cout << "fromC address: " << fromC << std::endl;
19.  
    std::cout << std::endl;
20.  
     
21.  
    std::cout << "vbptr address: " << (int*)d << std::endl;
22.  
    std::cout << " [0] => " << *(int*)(*(int*)d) << std::endl;
23.  
    std::cout << " [1] => " << *(((int*)(*(int*)d)) + 1)<< std::endl; // 偏移量20
24.  
    std::cout << "dataB value : " << *((int*)d + 1) << std::endl;
25.  
    std::cout << "vbptr address: " << ((int*)d + 2) << std::endl;
26.  
    std::cout << " [0] => " << *(int*)(*((int*)d + 2)) << std::endl;
27.  
    std::cout << " [1] => " << *((int*)(*((int*)d + 2)) + 1) << std::endl; // 偏移量12
28.  
    std::cout << "dataC value : " << *((int*)d + 3) << std::endl;
29.  
    std::cout << "dataD value : " << *((int*)d + 4) << std::endl;
30.  
    std::cout << "dataA value : " << *((int*)d + 5) << std::endl;
31.  
    }

得到结果为：