当前位置：首页 > news >正文

大话C++：第20篇多继承与菱形继承问题

news 2024/10/22 15:32:09

1 多继承概念

多继承是面向对象编程中的一个概念，指的是一个类可以继承自多个父类。通过多继承，子类可以获取多个父类的属性和方法，从而实现代码的重用和功能的扩展。多继承的语法格式：

// 基类
class Base1 
{// Base1 的成员
};// 基类
class Base2 
{// Base2 的成员
};// 派生类
class Derived : public Base1, public Base2 
{// Derived 类的成员
};

其中，

Derived 类同时继承了 Base1 和 Base2 类的成员
Derived 类的对象可以访问 Base1 和 Base2 类中定义的所有公有（public）和受保护（protected）成员。

然而，多继承也引入了一些复杂性和潜在的冲突。多继承带来了几个潜在的问题：

菱形继承（Diamond Inheritance）：当两个基类都从同一个类继承，并且一个类同时继承自这两个基类时，就可能出现菱形继承。这种情况下，继承层次结构呈现出一个菱形的形状，可能导致多重继承的歧义。例如，如果基类 Base 有一个成员 x，而两个派生类 Derived1 和 Derived2 都从 Base 继承 x，然后有一个类 Final 继承了 Derived1 和 Derived2，那么在 Final 类中访问 x 就会产生歧义。
重复的成员：如果多个基类有相同的成员变量或成员函数，那么在派生类中可能会出现重复的成员。这可能会导致命名冲突和不确定性，因为派生类的对象可能会有多个相同名称的成员。
初始化顺序：在多继承中，基类的构造函数调用顺序是重要的。如果基类之间存在依赖关系，必须确保它们按照正确的顺序进行初始化。

2 菱形继承

菱形继承（Diamond Inheritance）是多继承中的一个特定情况，也被称为“钻石问题”或“死亡之钻”。当两个或多个子类继承自同一个父类，并且有一个子类同时继承自这两个或多个子类时，就形成了一个菱形的继承结构。

在菱形继承中，可能会出现一个问题，即子类中的成员与父类中的成员发生冲突。如果父类有一个成员变量或成员函数，而两个子类都继承了这个成员，那么当有一个子类（称为“孙子类”）同时继承自这两个子类时，就会出现命名冲突和歧义。

#include <iostream>// 基类 Animal
class Animal 
{
public:// 构造函数Animal(){std::cout << "调用Animal构造函数" << std::endl;}// 析构函数 ~Animal(){std::cout << "调用Animal析构函数" << std::endl;}virtual void Speak() const {std::cout << "动物在嚎叫！" << std::endl;}
};// 第一个派生类 Mammal
class Mammal : public Animal 
{
public:// 构造函数Mammal(){std::cout << "调用Mammal构造函数" << std::endl;}// 析构函数 ~Mammal(){std::cout << "调用Mammal析构函数" << std::endl;}void Speak() const override {std::cout << "哺乳动物在嚎叫！" << std::endl;}
};// 第二个派生类 Bird
class Bird : public Animal 
{
public:// 构造函数Bird(){std::cout << "调用Bird构造函数" << std::endl;}// 析构函数 ~Bird(){std::cout << "调用Bird析构函数" << std::endl;}void Speak() const override {std::cout << "鸟在嚎叫！" << std::endl;}
};// 最终派生类 Bat，形成菱形继承
// Bat 类同时继承了 Mammal 和 Bird，它们都继承自 Animal
class Bat : public Mammal, public Bird 
{
};int main() 
{Bat bat;// 尝试调用 speak() 函数，这将导致多重继承的歧义// bat.Speak(); return 0;
}

其中，Bat类继承了Mammal和Bird类，而这两个类都继承自Animal类。由于Bat类没有重写speak()方法，因此当我们尝试调用bat.speak()时，编译器不知道应该调用Mammal类中的speak()还是Bird类中的speak()，因此会报错。

为了解决这个问题，C++ 提供了以下几种方法：

虚继承（Virtual Inheritance）：通过在共同基类前添加 virtual 关键字，可以确保在菱形继承结构中只继承基类的一个实例。这消除了多重继承的歧义性。
使用作用域解析运算符（::）：在调用有歧义的成员函数时，可以显式地指定要使用的基类。这要求我们知道哪个基类的成员是我们想要调用的。
重写歧义函数：在派生类中重写有歧义的函数，这样就我们可以提供一个没有歧义的实现。
避免菱形继承：在设计类层次结构时，尽量避免菱形继承。你可以通过重新设计类结构来消除这种继承模式，例如，通过使用接口（纯虚函数的类）或组合（包含其他类的对象）而不是继承。

3 虚继承解决菱形继承的有效方法

虚继承（virtual inheritance）是C++提供的一种机制，用于解决菱形继承带来的问题。通过使用虚继承，可以确保在菱形继承结构中，父类只被继承一次，从而消除多重继承的歧义。

在继承列表中使用virtual关键字来声明虚继承。当一个类虚继承自其基类时，它将只包含基类的一个实例，而不是每个继承路径上的一个实例。这确保了当子类访问基类成员时，只会有一个成员被访问，从而消除了歧义。

#include <iostream>// 基类 Animal
class Animal 
{
public:// 构造函数Animal(){std::cout << "调用Animal构造函数" << std::endl;}// 析构函数 ~Animal(){std::cout << "调用Animal析构函数" << std::endl;}virtual void Speak() const {std::cout << "动物在嚎叫！" << std::endl;}
};// 第一个派生类 Mammal
class Mammal : virtual public Animal 
{
public:// 构造函数Mammal(){std::cout << "调用Mammal构造函数" << std::endl;}// 析构函数 ~Mammal(){std::cout << "调用Mammal析构函数" << std::endl;}void Speak() const override {std::cout << "哺乳动物在嚎叫！" << std::endl;}
};// 第二个派生类 Bird
class Bird : virtual public Animal 
{
public:// 构造函数Bird(){std::cout << "调用Bird构造函数" << std::endl;}// 析构函数 ~Bird(){std::cout << "调用Bird析构函数" << std::endl;}void Speak() const override {std::cout << "鸟在嚎叫！" << std::endl;}
};// 最终派生类 Bat，形成菱形继承
// Bat 类同时继承了 Mammal 和 Bird，它们都继承自 Animal
class Bat : public Mammal, public Bird 
{
public:    // 构造函数Bat() { std::cout << "调用Bat构造函数" << std::endl; }// 析构函数~Bat() { std::cout << "调用Bat析构函数" << std::endl; }// 可以选择重写 speak() 方法，如果不重写则使用 Mammal 或 Bird 中的实现void Speak() const override{std::cout << "蝙蝠在嚎叫！" << std::endl;}    
};int main() 
{Bat bat;// 现在可以无歧义地调用Speak() 方法bat.Speak(); return 0;
}

其中，Animal类被虚继承到Mammal和Bird类中。因此，当Bat类继承自Mammal和Bird时，Animal类只会被构造一次，从而消除了菱形继承带来的问题。Bat类可以选择是否重写speak()方法；如果不重写，它将使用Mammal或Bird中的实现（这取决于调用speak()时使用的路径，可能会导致歧义）。为了消除这种可能的歧义，最好在Bat类中重写speak()方法，提供一个明确的实现。

4 虚继承实现原理

为了更方便地说明问题，我们定义以下类：

class A {};
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

虚继承在内存中的布局：

虚基类指针（VBPtr）: 在包含虚基类的派生类中，编译器会添加一个指向虚基类表的指针，这个指针通常被称为虚基类指针（VBPtr）。在32位系统中，这个指针占用4个字节；在64位系统中，它占用8个字节。这个指针存在于每个包含虚基类的派生类对象中。
虚基类表（VBTable）: 虚基类表是一个由编译器维护的表，它包含了指向虚基类成员的指针。这个表不占用派生类的空间，而是由编译器在运行时动态维护。虚基类表中的每一项都是一个偏移量，这个偏移量指示了从虚基类指针到虚基类成员在对象中的实际地址的距离。

对象D在虚继承时，内存布局图示：

     +----------------+      +----------------+|    D的对象     |      |    虚基类表     |+----------------+      +----------------+| VBPtr (指向A)  |----->| 偏移量1 (到A)  || B的成员        |      | 偏移量2 (备用) || C的成员        |      +----------------+| A的成员        |+----------------+

其中，D的对象包含一个指向虚基类表的指针（VBPtr），这个指针指向虚基类表。虚基类表包含了一个偏移量，这个偏移量指示了从虚基类指针到A类成员在D对象中的实际地址的距离。

当D的对象需要访问A的成员时，它会首先查找虚基类指针，然后使用这个指针查找虚基类表。虚基类表中的偏移量会被用来定位A的成员在D对象中的实际位置。这样，D就可以正确地访问A的成员，而不受多重继承中菱形继承问题的影响。

欢迎您同步关注我们的微信公众号！！！