无功能覆盖的多重继承。 为什么模棱两可

Question

Here are my classes. This is just

#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;
}

And this gives me a compiler error saying the foo call is ambiguous.

Function foo is not overridden anywhere. I understand there are two instances of class Base because there is no virtual inheritance. So there are two 'var' variables. But I don't understand why the compiler is having ambiguity in foo call. Functions are not instance specific. They are class specific. Why is the compiler giving an error?

I am using Visual Studio 2013.

Thank you.

Answer 1

The multiple inheritance makes you inherit two times the function foo(): one as part of Derived_A and one as part of Derived_B , because each of it inherits its own BaseClass .

BaseClass      BaseClass
    |               |
Derived_A      Derived_A  
     \           /
      \         /
       Derived_AB

So the compiler doesn't know if it shall execute it with the data of the Derived_A or Derived_B subobject.

Solutions:

1) You can disambiguate explicitely in every call you make:

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

2) You can disambiguate explicitely at the class level, by defining a common foo, for example:

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

3) If you want to have only a single BaseClass for your Derived_AB , then you should make BaseClass a virtual base class for Derived_A and Derived_B . Then Derived_AB will have only one single BaseClass and the call to foo() is no longer ambiguous.

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

(PS in this case, you shall also define a BaseClass() initializer for Dervived_AB. )

Answer 2

Functions are not instance specific. They are class specific.

That is only true for static functions. Suppose I change your implementation of foo() to the following:

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

What do you expect ABDerObj.foo(); to print?

---

Since this is an answer, let me also provide two possible solutions.

If foo really is instance-specific (for example, because it uses the class field var , you can easily tell the compiler which Base::foo() you want to call (the Derived_A or the Derived_B version) by specifying which one you want to use

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

or by just throwing away the other part:

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

The latter is mostly useful if you have a block of code where you are going to use only the Derived_A functionality, for example:

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

On the other hand, if -- to stick with your terminology -- the definition of foo really depends on the class and not on the instance, make it static :

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

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

What you should really be looking into is whether you actually need multiple inheritance, especially with the same base class occurring more than once. Often once you start having these disambiguation problems they keep getting worse and a slight redesign of your code will make it much more maintainable.