没有函数覆盖的多重继承。为什么模棱两可

Question

这是我的课程。这只是

#include<iostream>
using namespace std;

class Base
{
public:
    int var;

    Base(int val) : var(val)
    {}

    void foo()
    {
        cout << "Class Base foo()" << endl;
    }
};

class Derived_A : public Base
{
public:
    Derived_A(int val) : Base(val)
    {}
};

class Derived_B : public Base
{
public:
    Derived_B(int val) : Base(val)
    {}
};

class Derived_AB : public Derived_A, public Derived_B
{
public:
    Derived_AB(int var1, int var2) : Derived_A(var1), Derived_B(var2)
    {}
};

int main(int argc, char** argv)
{
    Derived_AB ABDerObj(1,2);
    ABDerObj.foo();
    return 0;
}

这给了我一个编译器错误，说 foo 调用不明确。

函数 foo 不会在任何地方被覆盖。我知道 Base 类有两个实例，因为没有虚拟继承。所以有两个'var'变量。但我不明白为什么编译器在 foo 调用中有歧义。函数不是特定于实例的。它们是特定于类的。为什么编译器会报错？

我正在使用 Visual Studio 2013。

谢谢。

Answer 1

多重继承使你继承了两次函数 foo()：一次作为Derived_A 的一部分，另一次作为Derived_B 的一部分，因为每个都继承了自己的BaseClass。

BaseClass      BaseClass
    |               |
Derived_A      Derived_A  
     \           /
      \         /
       Derived_AB

所以编译器不知道它是否应该使用Derived_A 或Derived_B 子对象的数据来执行它。

解决方案：

1) 您可以在每次通话中明确消除歧义：

ABDerObj.Derived_A::foo();  // execute foo() for the Deived_A object

2) 你可以在类级别明确地消除歧义，通过定义一个通用的 foo，例如：

void foo()
{
    Derived_A::foo();   // you want all the foos called
    Derived_B::foo();
}

3) 如果您只想为您的 Derived_AB 提供一个 BaseClass，那么您应该将 BaseClass 设为 Derived_A 和 Derived_B 的虚拟基类。那么Derived_AB 将只有一个BaseClass 并且对foo() 的调用不再模棱两可。

        BaseClass
       /        \
      /          \
Derived_A      Derived_A  
     \           /
      \         /
       Derived_AB  

（PS 在这种情况下，您还应该为 Dervived_AB. 定义一个 BaseClass() 初始化器）

Answer 2

函数不是特定于实例的。它们是特定于类的。

这仅适用于静态函数。假设我将您的 foo() 实现更改为以下内容：

void foo()
{
    cout << "My value is " << var << endl;
}

您希望ABDerObj.foo(); 打印什么？

---

既然这是一个答案，那我也提供两个可能的解决方案。

如果foo 确实是特定于实例的（例如，因为它使用类字段var，您可以轻松告诉编译器您要调用哪个Base::foo()（Derived_A 或Derived_B版本）通过指定你想使用哪一个

ABDerObj.Derived_A.foo();      // prints: My value is 1
ABDerObj.Derived_B.foo();      // prints: My value is 2

或者只是扔掉另一部分：

((Derived_A) ABDerObj).foo();  // prints: My value is 1
((Derived_B) ABDerObj).foo();  // prints: My value is 2

如果您有一段代码只要使用Derived_A 功能，则后者最有用，例如：

Derived_A& ABDerObjPartA = ABDerObj;
ABDerObjPartA.foo();
// more code using ABDerObjPartA.

另一方面，如果 -- 坚持你的术语 -- foo 的定义确实取决于类而不是实例，则将其设为 static：

// In Base:
static void foo()
{
    cout << "Class Base foo()" << endl;
}

// in main():
ABDerObj.foo(); // This is now OK

你应该真正研究的是你是否真的需要多重继承，尤其是同一个基类出现多次。通常，一旦您开始遇到这些消歧问题，它们就会变得更糟，对您的代码进行轻微的重新设计就会使其更易于维护。