多重继承和纯虚函数

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 -> “interface_base”和“implementation_base ->” interface_base'继承虚拟，解决了问题，但我不明白为什么。有人可以解释一下发生了什么事吗？

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

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() 来满足。

有关更多信息，请参阅之前的问题 - 答案提供了一些很好的图表让这一切变得更加清晰。

Answer 2

通常的 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 公开继承：实施 --公共--> 接口 --public--> interface_base
• 通过implementation_base私有继承：implementation --private--> implementation_base --public--> interface_base

当客户端代码执行以下派生到基类转换之一时：

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

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

在这里，从implementation到interface_base的转换始终可以由客户端代码通过interface完成；另一条无法到达的路径根本不重要。 唯一的interface_base虚拟基是从implementation公开继承的。

在许多情况下，实现类（implementation，< code>implementation_base）将对客户端代码隐藏：仅公开接口类（interface、interface_base）的指针或引用。

Answer 3

对于“解决”钻石继承问题的情况，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 并提供一个 Icecream >GetAsDrink() 和 GetAsFood() 方法将返回代理，纯粹是为了显示为食物或饮料。否则，这表明有一个方法或对象接受 Food 但不知何故希望稍后将其视为 Drink，这只能通过 dynamic_cast 来实现，并且不必是更合适的设计。