с ++ реализация абстрактного класса в другой базовый класс

Question

Вопрос

Почему бы не попробовать виртуальное наследование, если это, кажется, решить мою проблему с бриллиантом наследования ниже?

Брифинг:

В процессе обучения C++, я пришел с некоторыми ошибками компилятора для следующего кода:

#include <stdlib.h> 
#include <iostream> 

class IFoo{ 
    public: 
    virtual void Hello() = 0; 
}; 

class Foo : public IFoo{ 
    public: 
    void Hello() 
    { 
     printf("Hello"); 
    } 
}; 

class IBar : public IFoo{ 
    public: 
    virtual void HelloWorld() = 0; 
}; 

class Bar : public IBar, public Foo{ 
    public: 
    void HelloWorld() 
    { 
     Hello(); 
     printf("World"); 
    } 
}; 

int main() 
{ 
    Bar b; 
    b.HelloWorld(); 

    system("pause"); 
    return 0; 
} 

Я хочу Бар реализовать абстрактный класс IBar, который имеет IFoo в качестве базового класса, но то я хочу, чтобы вся реализация IFoo предоставлялась вторым базовым классом Bar Foo.

Я получаю 2 ошибки компилятора (GCC 4.9.2): Один из них связан с двусмысленностями, а другой - с отсутствующими реализациями для абстрактного класса IFoo.

Затем я нашел this question и получил, чтобы встретить концепцию виртуального наследования, которая приведет меня к this page. После урока я добавил виртуальное наследование и все проблемы исчезли:

class Foo : public virtual IFoo{... 
class IBar : public virtual IFoo{... 

Но пользователь в question предложить не попробовать виртуальное наследование. Отсюда мой вопрос.

Answer 1

Ваш Hello() звонок в Bar::HelloWorld() неоднозначен. Компилятор не может сказать, пытаетесь ли вы позвонить Hello() с IBar или Foo. Вы можете позвонить Foo::Hello() или IBar::Hello() в свое место. При этом ваша структура наследования не имеет смысла.

Ваш класс Bar также должен переопределить Hello, что он наследует от IBar.

Если у вас есть C++ 11, было бы хорошей идеей, чтобы отметить виртуальные функции вы переопределение с override ключевым словом:

#include <stdlib.h> 
#include <iostream> 

class IFoo{ 
    public: 
    virtual void Hello() = 0; 
}; 

class Foo : public IFoo{ 
    public: 
    virtual void Hello() override 
    { 
     printf("Hello"); 
    } 
}; 

class IBar : public IFoo{ 
    public: 
    virtual void HelloWorld() = 0; 
}; 

class Bar : public IBar, public Foo{ 
    public: 
    virtual void HelloWorld() override 
    { 
     Foo::Hello(); 
     printf("World"); 
    } 

    void Hello() override {} 
}; 

int main() 
{ 
    Bar b; 
    b.HelloWorld(); 

    system("pause"); 
    return 0; 
} 

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

#include <stdlib.h> 
#include <iostream> 

class IFoo{ 
public: 
    virtual void Hello() = 0; 
}; 

class Foo : public IFoo{ 
public: 
    virtual void Hello() override 
    { 
     printf("Hello"); 
    } 
}; 

class IBar { 
public: 
    virtual void World() = 0; 
}; 

class Bar : public IBar{ 
public: 
    virtual void World() override 
    { 
     printf("World"); 
    } 
}; 

class FooBar : public Foo, public Bar 
{ 
public: 
    virtual void HelloWorld() 
    { 
     Hello(); 
     World(); 
    } 
}; 

int main() 
{ 
    FooBar b; 
    b.HelloWorld(); 

    system("pause"); 
    return 0; 
} 

Answer 2

Ваш класс

Bar 

необходимо переопределить

Hello 

иначе класс Bar также становится чисто абстрактным, потому что

Hello 

наследуется весь путь от

IFoo. 

Всякий раз, когда класс наследует базовый класс Abtract он должен выполнить все чисто виртуальных функций базового класса, в противном случае сам производный класс также становится абстрактным.

class Base{ 
public: 
    virtual void foo() = 0; 
}; 

// this class is abstract, it doesn't implement Base::foo 
class Derived1 : public Base{ 
public: 
    void fooDerived() {} 
}; 

// this class is not abstract, it implements Base::foo 
class Derived2 : public Base{ 
public: 
    void foo() {} 
}; 

Как предложено в другом ответе, в C++ 11 вы можете объявить функцию, используя переопределения ключевое слово, которое гарантирует, что функция отменяет виртуальную функцию. Как это:

// this class is not abstract, it implements Base::foo 
class Derived2 : public Base{ 
public: 
    void foo() override {} 
}; 

Виртуальное наследование решает другую проблему, проблема неоднозначности при наследовании от более чем одного базового класса, который декларирует одинаковые функции или членов.