C++ 虚继承（虚基类表指针与虚基类表）

在Ｃ++中，我们会遇到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>
#include<string>
using namespace std;

class  A
{
public:
	A(int a) :ma(a)
	{
		std::cout << "A" << std::endl;
	}
	~A()
	{
		std::cout << "~A" << std::endl;
	}
public:
	int ma;
};
class B : public A
{
public:
	B(int b) :A(b), mb(b)
	{
		std::cout << "B" << std::endl;
	}
	~B()
	{
		std::cout << "~B" << std::endl;
	}
public:
	int mb;
};
class C : public A
{
public:
	C(int c) :A(c), mc(c)
	{
		std::cout << "C" << std::endl;
	}
	~C()
	{
		std::cout << "~C" << std::endl;
	}
public:
	int mc;
};
class E
{
public:
	E(int e) :me(e)
	{
		std::cout << "E" << std::endl;
	}
	~E()
	{
		std::cout << "~E" << std::endl;
	}
public:
	int me;
};
class D :public B, virtual public E ,public C
{
public:
	D(int d) :md(10), B(d), C(d), E(d)
	{
		std::cout << "D" << std::endl;
	}
	~D()
	{
		std::cout << "~D" << std::endl;
	}
public:
	int md;
};

int main()
{
	std::cout << "D size: " << sizeof(D) << std::endl;
	return 0;
}

 内存布局为：

虚基类指针指向的虚基类表为：

没有虚继承前的内存布局为：

 

但是E类是被虚继承的，所以，要把E类的内存放到派生类的内存下面

#include<iostream>
#include<string>
using namespace std;

class  A
{
public:
	A(int a) :ma(a)
	{
		std::cout << "A" << std::endl;
	}
	~A()
	{
		std::cout << "~A" << std::endl;
	}
public:
	int ma;
};
class B : virtual public A
{
public:
	B(int b) :A(b), mb(b)
	{
		std::cout << "B" << std::endl;
	}
	~B()
	{
		std::cout << "~B" << std::endl;
	}
public:
	int mb;
};
class C : virtual public A
{
public:
	C(int c) :A(c), mc(c)
	{
		std::cout << "C" << std::endl;
	}
	~C()
	{
		std::cout << "~C" << std::endl;
	}
public:
	int mc;
};
class E
{
public:
	E(int e) :me(e)
	{
		std::cout << "E" << std::endl;
	}
	~E()
	{
		std::cout << "~E" << std::endl;
	}
public:
	int me;
};
class D :public B, virtual public E ,public C
{
public:
	D(int d) :md(10), B(d),E(d),C(d),A(d)
	{
		std::cout << "D" << std::endl;
	}
	~D()
	{
		std::cout << "~D" << std::endl;
	}
public:
	int md;
};

int main()
{
	std::cout << "D size: " << sizeof(D) << std::endl;
	return 0;
}

内存布局为：

虚基类表为：

没有虚继承的时候，内存布局为：

有虚继承后，内存布局变为如下图：因为E类和A类不在同一个层次，所以vbptr存在合并，合并到B类的vbptr

#include<iostream>
#include<string>
using namespace std;

class  A
{
public:
	A(int a) :ma(a)
	{
		std::cout << "A" << std::endl;
	}
	~A()
	{
		std::cout << "~A" << std::endl;
	}
public:
	int ma;
};
class B : virtual public A
{
public:
	B(int b) :A(b), mb(b)
	{
		std::cout << "B" << std::endl;
	}
	~B()
	{
		std::cout << "~B" << std::endl;
	}
public:
	int mb;
};
class C : virtual public A
{
public:
	C(int c) :A(c), mc(c)
	{
		std::cout << "C" << std::endl;
	}
	~C()
	{
		std::cout << "~C" << std::endl;
	}
public:
	int mc;
};
class E
{
public:
	E(int e) :me(e)
	{
		std::cout << "E" << std::endl;
	}
	~E()
	{
		std::cout << "~E" << std::endl;
	}
public:
	int me;
};
class D :virtual public B, virtual public E ,public C
{
public:
	D(int d) :md(10),B(d),E(d),C(d),A(d)
	{
		std::cout << "D" << std::endl;
	}
	~D()
	{
		std::cout << "~D" << std::endl;
	}
public:
	int md;
};

int main()
{
	std::cout << "D size: " << sizeof(D) << std::endl;
	return 0;
}

 内存布局为：

俩个虚基类指针分别指向的虚基类表为：

 

虚基类和虚函数结合

#include<iostream>
#include<string>
using namespace std;

class  A
{
public:
	A(int a) :ma(a)
	{
		std::cout << "A" << std::endl;
	}
	virtual void show()
	{
		cout<<"虚函数和虚基类结合A"<<endl;
	}
	~A()
	{
		std::cout << "~A" << std::endl;
	}
public:
	int ma;
};
class B : virtual public A
{
public:
	B(int b) :A(b), mb(b)
	{
		std::cout << "B" << std::endl;
	}
	 void show()
	{
		cout<<"虚函数和虚基类结合B"<<endl;
	}
	~B()
	{
		std::cout << "~B" << std::endl;
	}
public:
	int mb;
};
class C : virtual public A
{
public:
	C(int c) :A(c), mc(c)
	{
		std::cout << "C" << std::endl;
	}
	void show()
	{
		cout<<"虚函数和虚基类结合C"<<endl;
	}
	~C()
	{
		std::cout << "~C" << std::endl;
	}
public:
	int mc;
};
class E
{
public:
	E(int e) :me(e)
	{
		std::cout << "E" << std::endl;
	}
	~E()
	{
		std::cout << "~E" << std::endl;
	}
public:
	int me;
};
class D :public B, virtual public E ,public C
{
public:
	D(int d) :md(10),B(d),E(d),C(d),A(d)
	{
		std::cout << "D" << std::endl;
	}
	void show()
	{
		cout<<"虚函数和虚基类结合D"<<endl;
	}
	~D()
	{
		std::cout << "~D" << std::endl;
	}
public:
	int md;
};

int main()
{
	D d(20);
	d.show();
	std::cout << "D size: " << sizeof(D) << std::endl;
	return 0;
}

内存布局为：

其中的虚基类指针指向的虚基类表为：

其中虚函数指针指向的虚表为：

建立一个不能被继承的类

   那么我们先了解一下友元关系的特点：

    友元关系
            1.单向性
            2.不可传递
            3.不可继承

class Base
{
private:
	Base(){}
	friend class A;
};
class A:virtual public Base
{
public:
	A(int a):ma(a){}
private:
	int ma;
};

此时A类不能被任何类调用，因为Base类的构造函数写在私有中，此时Base类派生了A类，添加了虚继承，并且还是友元函数，因此，虚基类构造函数的参数必须由最新派生出来的类负责初始化（即使不是直接继承）；因此A初始化Base，A在被其他类调用的时候，新的派生类要初始化Base类，但是Base类的构造函数在私有中，不能别别的类调用