C++ 菱形继承与虚拟继承的详解与代码示例-CSDN博客

本文链接：https://blog.csdn.net/shuai_258/article/details/141957210

在C++中，多重继承虽然强大，但也会带来不少问题。特别是当继承链中出现菱形继承时，容易导致基类的重复实例化。本文将深入讨论菱形继承的问题，并详细解释如何通过虚拟继承来解决它。同时，给出一个简单的代码示例，并逐步解析输出结果。

什么是菱形继承？

菱形继承是指在多重继承中，同一个基类被多个派生类继承，而这些派生类又被另一个类继承，最终形成菱形结构，如下图所示：

    A
   / \
  B   C
   \ /
    D

类 B 和 C 都继承了基类 A。
类 D 继承了 B 和 C。

在这种结构中，D 类通过 B 和 C 继承了 A，这意味着 D 类中可能会存在两个 A 类的实例，导致数据重复、内存浪费以及二义性问题。

菱形继承的问题

多重基类实例：当 D 类继承自 B 和 C 时，由于 B 和 C 都继承了 A，所以 D 类中有两个 A 的实例。如下所示：

class A {
public:
    int data;
};

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

int main() {
    D d;
    // 访问 A 类的成员变量 data 会导致二义性问题
    d.data = 10;  // 错误：编译器无法确定该选择 B::A 还是 C::A
}

这种情况下，编译器会提示二义性错误，因为无法确定 d.data 是来自 B 中的 A 还是 C 中的 A。

如何通过虚拟继承解决？

C++ 提供了虚拟继承（virtual inheritance）来解决菱形继承中基类实例重复的问题。通过在继承基类时使用 virtual 关键字，可以确保基类的实例在最终派生类中只存在一份。

虚拟继承语法

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

当 B 和 C 通过虚拟继承自 A 时，A 的实例不会被重复创建，D 类中的 A 实例只会有一份。

虚拟继承的代码示例

#include <iostream>

// 基类 A
class A {
public:
    int data;
    A() : data(0) {
        std::cout << "A's constructor called" << std::endl;  // 输出 1
    }

    void show() {
        std::cout << "A::data = " << data << std::endl;  // 输出 6
    }
};

// 派生类 B 虚拟继承自 A
class B : virtual public A {
public:
    B() {
        std::cout << "B's constructor called" << std::endl;  // 输出 2
    }
};

// 派生类 C 虚拟继承自 A
class C : virtual public A {
public:
    C() {
        std::cout << "C's constructor called" << std::endl;  // 输出 3
    }
};

// 最终派生类 D 同时继承自 B 和 C
class D : public B, public C {
public:
    D() {
        std::cout << "D's constructor called" << std::endl;  // 输出 4
    }
};

int main() {
    D d;  // 创建 D 类对象，依次调用 A、B、C、D 的构造函数
    // 输出顺序为：A's constructor -> B's constructor -> C's constructor -> D's constructor

    d.data = 100;  // 修改 A 中的成员变量 data
    d.show();  // 调用 A 的 show 函数，输出 A::data = 100
    return 0;
}

输出结果

A's constructor called   // 由 A 的构造函数触发，这是基类的构造顺序，最先被调用。
B's constructor called   // 由 B 的构造函数触发，B 虚拟继承 A，但 A 已经构造过了。
C's constructor called   // 由 C 的构造函数触发，C 虚拟继承 A，A 仍然只会构造一次。
D's constructor called   // 由 D 的构造函数触发，最后构造 D。
A::data = 100            // 调用 A 的 show 函数，输出 A::data 的值为 100。

详细解析

A's constructor called：D 类对象创建时，首先调用 A 类的构造函数。因为 B 和 C 都虚拟继承自 A，所以 A 的实例只被构造一次。
B's constructor called：接着调用 B 的构造函数，但 A 不会再次构造。
C's constructor called：然后调用 C 的构造函数，同样 A 不会再次构造。
D's constructor called：最后调用 D 的构造函数。
A::data = 100：调用 d.show() 方法，输出 A::data 的值，验证修改操作生效。