多重继承和纯虚函数

Question

以下代码：

struct interface_base
{
    virtual void foo() = 0;
};

struct interface : public interface_base
{
    virtual void bar() = 0;
};

struct implementation_base : public interface_base
{
    void foo();
};

struct implementation : public implementation_base, public interface
{   
    void bar();
};

int main()
{
    implementation x;
}

编译失败，出现以下错误：

test.cpp: In function 'int main()':
test.cpp:23:20: error: cannot declare variable 'x' to be of abstract type 'implementation'
test.cpp:16:8: note:   because the following virtual functions are pure within 'implementation':
test.cpp:3:18: note:    virtual void interface_base::foo()

我玩过它并发现将“接口 - > interface_base”和“implementation_base - > interface_base”继承虚拟化可以解决问题，但我不明白为什么。有人可以解释发生了什么吗？

附言我故意省略了虚拟析构函数以使代码更短。请不要告诉我把它们放进去，我已经知道了:)

Answer 1

您的继承树中有两个 interface_base 基类。这意味着您必须提供foo() 的两个 实现。调用它们中的任何一个都会非常尴尬，需要多次转换才能消除歧义。这通常不是您想要的。

要解决此问题，请使用虚拟继承：

struct interface_base
{
    virtual void foo() = 0;
};

struct interface : virtual public interface_base
{
    virtual void bar() = 0;
};

struct implementation_base : virtual public interface_base
{
    void foo();
};

struct implementation : public implementation_base, virtual public interface
{   
    void bar();
};

int main()
{
    implementation x;
}

使用虚拟继承，只有一个相关基类的实例会在所有虚拟提及的继承层次结构中创建。因此，只有一个foo()，可以满足implementation_base::foo()。

如需更多信息，see this prior question - 答案提供了一些漂亮的图表，让这一切更加清晰。

Answer 2

对于“解决”菱形继承问题，bdonlan 提供的解决方案是有效的。话虽如此，您可以避免设计的钻石问题。为什么必须将给定类的每个实例都视为两个类？您是否曾经将同一个对象传递给类似以下内容的类：

void ConsumeFood(Food *food);
void ConsumeDrink(Drink *drink);

class NutritionalConsumable {
  float calories() = 0;
  float GetNutritionalValue(NUTRITION_ID nutrition) = 0;
};
class Drink : public NutritionalConsumable {
  void Sip() = 0;
};
class Food : public NutritionalConsumable {
  void Chew() = 0;
};
class Icecream : public Drink, virtual public Food {};

void ConsumeNutrition(NutritionalConsumable *consumable) {
  ConsumeFood(dynamic_cast<Food*>(food));
  ConsumeDrink(dynamic_cast<Drink*>(drink));
}

// Or moreso
void ConsumeIcecream(Icecream *icecream) {
  ConsumeDrink(icecream);
  ConsumeFood(icecream);
}

当然，在这种情况下，Icecream 最好只实现 NutritionalConsumable 并提供将返回代理的 GetAsDrink() 和 GetAsFood() 方法，纯粹是为了显示为食物或饮料。否则，这表明有一个方法或对象接受Food，但不知何故希望稍后将其视为Drink，这只能通过dynamic_cast 来实现，并且不需要更多适当的设计。

Answer 3

通常的 C++ 习语是：

• 接口类的公共虚拟继承
• 实现类的私有非虚拟继承

在这种情况下，我们会：

struct interface_base
{
    virtual void foo() = 0;
};

struct interface : virtual public interface_base
{
    virtual void bar() = 0;
};

struct implementation_base : virtual public interface_base
{
    void foo();
};

struct implementation : private implementation_base,
                        virtual public interface
{   
    void bar();
};

在implementation 中，唯一的interface_base 虚拟基是：

• 通过interface公开继承：implementation --public--> interface --public--> interface_base
• 通过implementation_base私有继承：implementation --private--> implementation_base --public--> interface_base

当客户端代码执行其中一种派生到基础的转换时：

• 派生到基指针转换，
• 基类型的引用绑定与派生的静态类型的初始值设定项，
• 通过派生静态类型的左值访问继承的基类成员，

重要的是从派生类到给定的基类子对象至少有一个可访问的继承路径；其他无法访问的路径将被忽略。因为基类的继承在这里只是虚的，所以只有一个基类主体，所以这些转换永远不会有歧义。

在这里，从implementation 到interface_base 的转换，总是可以由客户端代码通过interface 完成；其他无法访问的路径根本无关紧要。 唯一的interface_base 虚拟基础是从implementation 公开继承的。

在许多情况下，实现类（implementation、implementation_base）将对客户端代码隐藏：只有对接口类（interface、interface_base）的指针或引用会被暴露。