C++: производный + базовый класс реализует единый интерфейс?

C++ не замечает, что функция, унаследованная от Base, уже реализует BaseFunction: функция должна быть явно реализована в классе, производном от Interface. Измените это следующим образом:

class Interface
{
    public:
        virtual void BaseFunction() = 0;
        virtual void DerivedFunction() = 0;
};

class Base : public Interface
{
    public:
        virtual void BaseFunction(){}
};

class Derived : public Base
{
    public: 
        virtual void DerivedFunction(){}
};

int main()
{
    Derived derived;
}

Если вы хотите реализовать только один из них, разделите Interface на два интерфейса:

class DerivedInterface
{
    public:
        virtual void DerivedFunction() = 0;
};

class BaseInterface
{
    public:
        virtual void BaseFunction() = 0;
};

class Base : public BaseInterface
{
    public:
        virtual void BaseFunction(){}
};

class Derived : public DerivedInterface
{
    public: 
        virtual void DerivedFunction(){}
};  

class Both : public DerivedInterface, public Base {
    public: 
        virtual void DerivedFunction(){}
};

int main()
{
    Derived derived;
    Base base;
    Both both;
}

Примечание: функция main должна возвращать значение int
Примечание: рекомендуется хранить virtual перед функциями-членами производной функции, которые были виртуальными в базе, даже если это не является строго обязательным.

Похоже, что это не совсем тот случай, когда Derived «является» Base, что предполагает, что сдерживание может быть лучшей реализацией, чем наследование.

Кроме того, ваши производные функции-члены также должны быть обозначены как виртуальные.

class Contained
{
    public:
        void containedFunction() {}
};

class Derived
{
    public:
        virtual void derivedFunction() {}
        virtual void containedFunction() {return contained.containedFunction();}
    private:
        Containted contained;
};

Вы можете сделать содержащийся элемент ссылкой или интеллектуальным указателем, если хотите скрыть детали реализации.

Проблема в том, что в вашем примере у вас есть две реализации Interface, одна из Base, а другая из Derived. Это сделано на языке C++. Как уже было сказано, просто удалите базовый класс Interface в определении Derived.

Я согласен с ответом литб. Однако здесь есть возможность кое-что понять о том, как работают виртуальные функции и множественное наследование.

Когда класс имеет несколько базовых классов, у него есть отдельные виртуальные таблицы для каждого базового класса. Derived будет иметь структуру виртуальной таблицы, которая выглядит следующим образом:

Derived
 vtable: Interface
   BaseFunction*
   DerivedFunction*
 vtable: Base
   BaseFunction*

Кроме того, каждый базовый класс сможет видеть только свою виртуальную таблицу. Когда создается экземпляр Base, он заполняет указатель Base::BaseFunction в виртуальной таблице, но не может видеть виртуальную таблицу для интерфейса.

Если бы предоставленный вами код мог скомпилироваться, результирующая структура vtable экземпляра Derived выглядела бы так:

Derived
 vtable: Interface
   BaseFunction* = 0
   DerivedFunction* = Derived::DerivedFunction
 vtable: Base
   BaseFunction* = Base::BaseFunction

Я обнаружил, что в ответе litb не хватает одной вещи. Если у меня есть экземпляр Derived, я могу получить DerivedInterface и BaseInterface. Но если у меня есть только DerivedInterface, я не могу получить BaseInterface, так как получение DerivedInterface из BaseInterface не сработает.

Но все это время я по какой-то причине ограничивал себя проверкой времени компиляции. Этот DerivedInterface отлично работает:

class DerivedInterface
{
    public:
        virtual void DerivedFunction() = 0;
        BaseInterface* GetBaseInterface()
            {return dynamic_cast<BaseInterface*>(this);}
};

void main()
{
    Derived derived;

    DerivedInterface* derivedInterface = &derived;
    derivedInterface->GetBaseInterface()->BaseFunction();
}

В Derived нет необходимости проходить через функции, и все довольны. Конечно, это уже не строго интерфейс, но это нормально. Почему я не подумал об этом раньше? :)