Множественное наследование без переопределения функции. Почему двусмысленность

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) Если вы хотите иметь только один BaseClass для Derived_AB, то вы должны сделать BaseClass виртуальным базовым классом для Derived_A и Derived_B. Тогда Derived_AB будет иметь только один сингл BaseClass, а звонок foo() больше не является двусмысленным.

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

(приписка в этом случае, вы должны также определить BaseClass() инициализатор для Dervived_AB.)

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 

Что вы должны действительно смотреть в ли вы на самом деле потребность множественное наследование, особенно с го один и тот же базовый класс, встречающийся более одного раза. Часто, как только вы начинаете сталкиваться с этими проблемами неоднозначности, они продолжают ухудшаться, а небольшая редизайн вашего кода сделает его гораздо более удобным.