【C++】虚继承（virtual base classes)

文章目录

【C++】虚继承（virtual base classes)
- 1. 使用原因
- 2. 解决方法
- 3. 例题练习

1. 使用原因

在多重继承(Multiple Inheritance) 的情况下，尤其是菱形继承时，容易出现问题，关于菱形继承见下图：

这个类 A 由另外两个类 B 和 C 继承。这两个类都继承到另一个新类 D 中
在这里插入图片描述
从图中我们可以看出，类 A 的数据/成员函数被两次继承到类 D。一个通过 B 类继承，另一个通过 C 类继承。当类 A 的任意数据/成员函数被类 D 的对象访问时，对于将调用哪个数据/成员函数会产生歧义，是调用通过 B 继承的，还是调用通过 C 继承的。这会混淆编译器并显示错误。

举个具体的例子
已知类 B 和 C 继承自 A 类，在 A 类中有变量 a

class A
{
public:
	int a;
};

在 B 中定义获取 a 的方法 Get， C 中定义设置 a 的方法 Set，

class B : public A
{
public:
	 int Get() { return a; }
};

class C : public A
{
public:
	void Set(int val) { a = val; }
};

此时 D 类 public 继承 B 和 C

class D : public B, public C
{};

那么使用 D 实例化的对象 dobject，调用 Get 和 Set 接口，所操作的变量 a 为同一个吗？

#include <iostream>
int main(int argc, char* argv[])
{
	D dobject;
	d.Set(10);
	std::cout << d.Get() << std::endl;// undefined value
	
	return 0;
}

答案是否定的，B，C 继承 A，则 B,C 中均有一个 a 变量， B 中的 Get 只能操作 B 中的 a, C 中的 Set 只能操作 C 中的 a ，D 同时拥有了B 和 C 的所有属性，这就是问题所在了。

2. 解决方法

在类 B C 继承类 A 时，使用虚继承 (virtual inheritance)，或者叫虚基类 (virtual base classes) ，继承时额外使用 virtual 关键字

虚继承的语法为
class Derived : public virtual Base
{
};
// 或
class Derived : virtual public Base
{
};
virtual 关键字和继承限定符(public,protected,private) 谁在前，谁在后都可以。

也就是：

在这里插入图片描述

class B : public virtual A
{
public:
	int Get() { return a; }
};

class C : virtual public A
{
public:
	void Set(int val) { a = val };
};

现在，只有数据/成员函数的一个副本将被复制到类 C 和类 B 中，类 A 成为虚基类 (virtual base class)。虚基类提供了一种节省空间并避免使用多个继承的类层次结构中出现歧义的方法。将基类指定为虚拟基类时，它可以多次充当间接基类，而不会重复其数据成员。其数据成员的单个副本由使用虚拟基的所有基类共享。

此时 D 再正常继承 B，C 则不会出现问题，
在构建 D 类对象时，构建 B 和 C 时，不构建 B 和 C 类对象中的 A，只构建一次 A ，则在 D 的对象中只存在一个 a 变量

class D : public B, public C
{};

#include <iostream>
int main(int argc, char* argv[])
{
	D dobject;
	d.Set(10);
	std::cout << d.Get() << std::endl;// 10
	
	return 0;
}

3. 例题练习

我们可以看一下菱形继承虚继承具体是如何实例化的

#include <iostream>

class A {
public:
  A(const char* s) 
  { std::cout << s << std::endl; }
};

class B : public virtual A {
public:
    B(const char* s1, const char* s2) : A(s1)
    { std::cout << s2 << std::endl; }
};

class C : public virtual A {
public:
    C(const char* s1, const char* s2) : A(s1) 
    { std::cout << s2 << std::endl; }
};

class D : public B, C {
public:
    D(const char* s1, const char* s2, const char* s3, const char* s4) 
    : B(s1, s2), C(s3, s4), A(s1)
    {
        std::cout << s4 << std::endl;
    }
};

int main(int argc, char* argv[])
{
    D dobject("class A", "class B", "class C", "class D");

	return 0;
}