C++虚继承详解

看侯捷老师的C++内存模型时，讲到了虚继承。虚继承算是C++特有的知识了，特此记录下。

什么是虚继承

由于C++支持多继承，可能会出现菱形继承，代码如下：

#include <iostream> // std::cout std::endl

class base
{
public:
    long long par=0;
    void show(int par) const noexcept;
};

void base::show(int par) const noexcept
{
    par=par;
    std::cout << "par:" << par << std::endl;
}

class derived1 : public base{};

class derived2 : public base{};

class final_derived : public derived1, public derived2
{
public:
    long long fpar=3;
};

int main(void)
{
    final_derived object;
    // 两个show()函数，编译器不知道调用哪个
    object.show();  
    return 0;
}

首先需要明白，编译器寻找普通成员函数时，和this指针有关系：

this指针是一个指针常量，其地址不能改变，指向当前对象，做为成员函数的第一个默认缺省参数，由编译器管理。

this指针的两个作用：
其一，类似于模板函数的类型推导确定对象所属类型，所以不同的类调用同名函数，是不会出现问题的，并确定函数操作的数据块大小；其二，它的值就是对象object的地址；

因此，通过this指针，当存在多个同名函数时，编译可以根据对象推导参数类型，找到这个类对应的函数，并操作对应空间的数据。

接下里，剖析下多继承中菱形继承问题。

多继承–成员函数方面

继承关系中的成员函数

由于函数会占用内存中代码区的资源，所以如果子类不用修改父类中的某一个成员函数，那直接用父类的这个函数就好了：

#include <iostream> 
using namespace std;

class base
{
public:
    long long par=0;
    void show(int par) const noexcept;
};

void base::show(int par) const noexcept
{
    par=par;
    std::cout << "par:" << par << std::endl;
}

class derived1 : public base{
public:
    void show(int par){
        cout<<"show of derived1"<<endl;
    }
};

class derived2 : public base{};

class final_derived :  public derived2,public derived1
{
public:
    long long fpar=3;
};

// 成员函数地址读取
template<typename dst_type,typename src_type>
dst_type pointer_cast(src_type src)
{
    // 巧妙地转换：由于static_cast不能转换两个毫不相关的变量，利用void* 进行转换
    return *static_cast<dst_type*>(static_cast<void*>(&src));
}

int main(void)
{
    base* p1 = pointer_cast<base*>(&base::show);
    derived1* p2 = pointer_cast<derived1*>(&derived1::show);
    derived2* p3 = pointer_cast<derived2*>(&derived2::show);
    cout<<p1<<endl<<p2<<endl<<p3<<endl;
    return 0;
}

三个成员函数的地址为：0x401550 0x4159c0 0x401550

可以看出：由于derived2的show函数就是用的base父类的show函数，而没有新建show函数；说的直白点，就是derived1的成员函数show实际变成了show(derived* const this,int par)，而derived2的成员函数show还是show(base* const this,int par)。

多继承中成员函数问题

接下来，并在main函数加入如下代码：

final_derived object;
object.show(1);

发现编译器直接报错：show函数目标不明确

一开始我是这么以为的：

这是由于final_derived没有重写show函数，所以会调用父类的show函数。然而，final_derived类调用show函数时，既能匹配show(derived* const this,int par)，也能匹配show(base* const this,int par)，编译器不明确到底调用哪个。

然而，实事并不是这样，我把derived1中的show函数删除了，也就是只剩一个show(base* const this,int par)了，但仍然出现show函数目标不明确的报错。所以，实事就是编译器在进行语法分析时，发现final_derived有两个相同的show函数，直接就报错了。

解决方法

为避免调用函数时，语法问题造成调用失败，有三种方法可以解决：

一、final_derived重写show函数:

class final_derived :  public derived2,public derived1
{
public:
    long long fpar=3;
    void show(int par){
        derived1::show(par);
    }
};

但这样有个缺点，本来final_derived就是用的derived1的方法，且未作任何修改，按C++的设计思想，直接用父类derived1类的show方法就可以了，不应该用额外的内存。

二、调用的时候，指定具体的类，给this指针传更精确的类型：

int main(void)
{
    final_derived object;
    object.derived1::show(1);
    object.derived2::show(2);
    return 0;
}

这样就是写代码会很麻烦，别人还得知道你是怎么继承的。

三、虚继承

也就是在derived1类和derived2类继承base时，添加virtual关键字：

#include <iostream> 
using namespace std;

class base
{
public:
    long long par=0;
    void show(int par) const noexcept;
};

void base::show(int par) const noexcept
{
    par=par;
    std::cout << "par:" << par << std::endl;
}

class derived1 :  virtual public base{
public:
    void show(int par){
        std::cout << "show of derived1"<< std::endl;
    }
};

class derived2 :  virtual public base{};

class final_derived :  public derived2,public derived1
{
public:
    long long fpar=3;
};

int main(void)
{
    final_derived object;
    object.show(1);
    return 0;
}

这里输出的是show of derived1。
如果删除derived1的show函数，输出为par=1，也就是调用base的show函数

虚继承实现原理

derived1 和 derived1 虚继承 base，会新建一个虚基类表，存储虚基类相对直接继承类的偏移量，并把指向虚基类表的虚基类指针存入类中。

这样，final_derived在调用show时，过程如下：

• 首先找自己类中有没有show函数；如果没有，找父类。
• 父类中如果能找到，就用父类的show函数。（注意：如果derived1和derived2都重写了show函数，object.show(1)仍然报目标不明确的错误）
• 找derived1和derived2和虚基类表，如果发现show函数在两个类中的虚基类表中都存在，就直接调用base的show函数。

可以看出，虚继承并不能保证object.show(1)的合法调用，最好不要用多继承，就把虚继承这种机制当作语法糖吧。

多继承–成员变量方面

继承中类成员变量的分布

删除上述代码的show函数，专注于成员变量par上，观察object对象中的成员变量分布，以及它的大小。

#include <iostream> 
using namespace std;

class base
{
public:
    long long par=0;
    void show(int par) const noexcept;
};

void base::show(int par) const noexcept
{
    par=par;
    std::cout << "par:" << par << std::endl;
}

class derived1 :  public base{};

class derived2 :  public base{};

class final_derived :  public derived2,public derived1
{
public:
    long long fpar=3;
};

int main(void)
{
    final_derived object;
    cout<<sizeof(object)<<endl;
    return 0;
}

其大小为24bytes（64位机器下），成员变量分布为：

依次是从derived2类继承的par，从derived1类继承的par，以及自身的fpra。由于final_derived是先继承的 derived2 后继承 derived1，因此从derived2继承来的par也分布在前端。

那么现在问题来了：其一：这个类中有两个par变量，要怎么访问呢？其二：从上述代码来看，final_derived直接用base的par就可以了，用两个par变量不是浪费空间吗？

解决办法

如果只解决第一个问题，可以通过指明具体类的方法：

cout<<object.derived1::par<<endl;

但如果还要解决第二个问题，仍然得借助虚继承,为了更方便说明，我加了两个参数par2和par3:

#include <iostream> 
using namespace std;

class base
{
public:
    long long par=0;
    long long par2=1;
    long long par3=2;
    void show(int par) const noexcept;
};

void base::show(int par) const noexcept
{
    par=par;
    std::cout << "par:" << par << std::endl;
}

class derived1 :  virtual public base{};

class derived2 :  virtual public base{};

class final_derived :  public derived2,public derived1
{
public:
    long long fpar=3;
};

int main(void)
{
    final_derived object;
    cout<<sizeof(object)<<endl;
    return 0;
}

输出结果为48bytes,内存分布从上到下依次为：derived2的虚基类指针，derived1的虚基类指针，final_derived自身的fpar，base的三个成员变量（单继承中，父类的成员变量是放前面的）。

访问成员变量类似于成员函数的调用，先看类本身是否存在这个变量，然后去父类中找，最后找父类的虚继承表。

题外话: 虽然我一直觉得组合比继承好，但这里用组合好像没啥办法省内存，算是继承的一个优点吧，但代价就是代码写起来很麻烦。

多继承（Multiple Inheritance）是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。尽管概念上非常简单，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突就是不可回避的一个。

多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如典型的是菱形继承，如下图所示：

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

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

//间接基类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;
}

这段代码实现了上图所示的菱形继承，第 25 行代码试图直接访问成员变量 m_a，结果发生了错误，因为类 B 和类 C 中都有成员变量 m_a（从 A 类继承而来），编译器不知道选用哪一个，所以产生了歧义。

为了消除歧义，我们可以在 m_a 的前面指明它具体来自哪个类：

void seta(int a){ B::m_a = a; }

这样表示使用 B 类的 m_a。当然也可以使用 C 类的：

void seta(int a){ C::m_a = a; }

虚继承（Virtual Inheritance）
为了解决多继承时的命名冲突和冗余数据问题，C++ 提出了虚继承，使得在派生类中只保留一份间接基类的成员。

在继承方式前面加上 virtual 关键字就是虚继承，请看下面的例子：

//间接基类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;
}

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

虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类（Virtual Base Class），本例中的 A 就是一个虚基类。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含一份虚基类的成员。

现在让我们重新梳理一下本例的继承关系，如下图所示：

观察这个新的继承体系，我们会发现虚继承的一个不太直观的特征：必须在虚派生的真实需求出现前就已经完成虚派生的操作。在上图中，当定义 D 类时才出现了对虚派生的需求，但是如果 B 类和 C 类不是从 A 类虚派生得到的，那么 D 类还是会保留 A 类的两份成员。

换个角度讲，虚派生只影响从指定了虚基类的派生类中进一步派生出来的类，它不会影响派生类本身。

在实际开发中，位于中间层次的基类将其继承声明为虚继承一般不会带来什么问题。通常情况下，使用虚继承的类层次是由一个人或者一个项目组一次性设计完成的。对于一个独立开发的类来说，很少需要基类中的某一个类是虚基类，况且新类的开发者也无法改变已经存在的类体系。

C++标准库中的 iostream 类就是一个虚继承的实际应用案例。iostream 从 istream 和 ostream 直接继承而来，而 istream 和 ostream 又都继承自一个共同的名为 base_ios 的类，是典型的菱形继承。此时 istream 和 ostream 必须采用虚继承，否则将导致 iostream 类中保留两份 base_ios 类的成员。

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

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

可以看到，使用多继承经常会出现二义性问题，必须十分小心。上面的例子是简单的，如果继承的层次再多一些，关系更复杂一些，程序员就很容易陷人迷魂阵，程序的编写、调试和维护工作都会变得更加困难，因此我不提倡在程序中使用多继承，只有在比较简单和不易出现二义性的情况或实在必要时才使用多继承，能用单一继承解决的问题就不要使用多继承。也正是由于这个原因，C++ 之后的很多面向对象的编程语言，例如 Java、C#、PHP 等，都不支持多继承。

在Ｃ++中，我们会遇到virtual这个关键字，但是它有两种含义：虚函数和虚继承，它们两个是完全无相关的两个概念。

什么是虚继承  

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

当一个基类被声明为虚基类后，即使它成为了多继承链路上的公共基类，最后的派生类中也只有它的一个备份。例如：

class CBase { }；
class CDerive1：virtual public CBase{ }；
class CDerive2：virtual public CBase{ }；
class CDerive12：public CDerive1，CDerive2{ }；

则在类CDerive12的对象中，仅有类CBase的一个对象数据

虚继承实现原理

虚继承底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现，每个虚继承的子类都有一个虚基类指针（任何类型的指针变量都是占用4个字节）和虚基类表（不占用类对象的存储空间）（需要强调的是，虚基类依旧会在子类里面存在拷贝，只是仅仅最多存在一份而已，并不是不在子类里面了）；当虚继承的子类被当做父类继承时，虚基类指针也会被继承。
实际上，vbptr指的是虚基类表指针，该指针指向了一个虚基类表，虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。

虚继承与虚函数的异同

相似之处：都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间）。
不同之处：虚基类依旧存在继承类中，只占用存储空间；虚函数不占用存储空间。虚基类表存储的是虚基类相对直接继承类的偏移；而虚函数表存储的是虚函数地址。

#include<iostream>  
using namespace std;

class A  //大小为4  
{
public:
	int a;
};
class B :virtual public A  //大小为12，变量a,b共8字节，虚基类表指针4  
{
public:
	int b;
};
class C :virtual public A //与B一样12  
{
public:
	int c;
};
class D :public B, public C //24,变量a,b,c,d共16，B的虚基类指针4，C的虚基类指针  
{
public:
	int d;
};

int main()
{
	A a;
	B b;
	C c;
	D d;
	cout << sizeof(a) << endl;
	cout << sizeof(b) << endl;
	cout << sizeof(c) << endl;
	cout << sizeof(d) << endl;
	system("pause");
	return 0;
}
//
//1 > class A	size(4) :
//1 > +-- -
//1 > 0 | a
//1 > +-- -
//1 >
//1 > class B	size(12) :
//1 > +-- -
//1 > 0 | {vbptr}
//1 > 4 | b
//1 > +-- -
//1 > +-- - (virtual base A)
//1 > 8 | a
//1 > +-- -
//1 >
//1 > B::$vbtable@:
//1 > 0 | 0
//1 > 1 | 8 (Bd(B + 0)A)
//1 > vbi:class  offset o.vbptr  o.vbte fVtorDisp
//1 >         A       8       0       4 0
//1 >
//1 > class C	size(12) :
//1 > +-- -
//1 > 0 | {vbptr}
//1 > 4 | c
//1 > +-- -
//1 > +-- - (virtual base A)
//1 > 8 | a
//1 > +-- -
//1 >
//1 > C::$vbtable@:
//1 > 0 | 0
//1 > 1 | 8 (Cd(C + 0)A)
//1 > vbi:class  offset o.vbptr  o.vbte fVtorDisp
//1 >         A       8       0       4 0
//1 >
//1 > class D	size(24) :
//1 > +-- -
//1 > 0 | +-- - (base class B)
//1 > 0	| | {vbptr}
//1 > 4	| | b
//1 > | +-- -
//1 > 8 | +-- - (base class C)
//1 > 8	| | {vbptr}
//1 > 12	| | c
//1 > | +-- -
//1 > 16 | d
//1 > +-- -
//1 > +-- - (virtual base A)
//1 > 20 | a
//1 > +-- -
//1 >
//1 > D::$vbtable@B@:
//1 > 0 | 0
//1 > 1 | 20 (Dd(B + 0)A)
//1 >
//1 > D::$vbtable@C@:
//1 > 0 | 0
//1 > 1 | 12 (Dd(C + 0)A)
//1 > vbi:class  offset o.vbptr  o.vbte fVtorDisp
//1 >         A      20       0       4 0
//1 >