Множественное наследование от одного и того же прародителя - объединить реализации?

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

В вашем случае происходит следующее: когда вы наследуете D, B::bar не реализовано, а C::foo не реализовано. Промежуточные классы B и C не могут видеть реализации друг друга.

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

Если ваш интерфейс верхнего уровня имеет логическое разделение по функциональности, вам следует разделить его на два отдельных интерфейса. Например, если у вас есть функции сериализации и рисования в интерфейсе A, вы должны разделить их на два интерфейса: ISerialization и IDrawing.

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

Существует также вероятность того, что вы могли бы использовать «фабричный» класс для основного типа интерфейса. Другими словами, основной класс интерфейса также содержит некоторый тип статической функции, которая генерирует соответствующий дочерний класс по запросу пользователя. Например:

#include <cstdio>

class A 
{
    public:
       enum class_t { CLASS_B, CLASS_C };

       static A* make_a_class(class_t type);

       virtual void foo() = 0;
       virtual void bar() = 0;
};

class B: public A
{
    private:
        virtual void foo() { /* does nothing */ }

    public:
        virtual void bar() { printf("Called B::bar()\n"); }
};

class C: public A
{
    private:
        virtual void bar() { /* does nothing */ }

    public:
        virtual void foo() { printf("Called C::foo()\n"); }
};

A* A::make_a_class(class_t type)
{
   switch(type)
   {
       case CLASS_B: return new B();
       case CLASS_C: return new C();
       default: return NULL;
    }
}

int main()
{
    B* Class_B_Obj = static_cast<B*>(A::make_a_class(A::CLASS_B));
    C* Class_C_Obj = static_cast<C*>(A::make_a_class(A::CLASS_C));

    //Class_B_Obj->foo(); //can't access since it's private
    Class_B_Obj->bar();

    Class_C_Obj->foo();
    //Class_C_Obj->bar(); //can't access since it's private

    return 0;
}

Если class A по какой-то причине требуется доступ к некоторым закрытым членам class B или class C, просто сделайте class A другом дочерних классов (например, вы можете сделать конструкторы class B и class C частными конструкторами, чтобы только статическая функция в class A могла генерировать их, и пользователь не может создать их самостоятельно, не вызывая статическую фабричную функцию в class A).

Надеюсь это поможет,

Джейсон

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

#include <iostream>

using namespace std;

enum class_t { CLASS_A, CLASS_B, CLASS_C };

template<class_t class_type>
class base_type
{
    public:
            static void foo() {}
            static void bar() {}
};

template<>
void base_type<CLASS_A>::foo() { cout << "Calling CLASS_A type foo()" << endl; }

template<>
void base_type<CLASS_B>::bar() { cout << "Calling CLASS_B type bar()" << endl; }

template<>
void base_type<CLASS_C>::foo() { base_type<CLASS_A>::foo(); }

template<>
void base_type<CLASS_C>::bar() { base_type<CLASS_B>::bar(); }

int main()
{
    base_type<CLASS_A> Class_A;
    Class_A.foo();

    base_type<CLASS_B> Class_B;
    Class_B.bar();

    base_type<CLASS_C> Class_C;
    Class_C.foo();
    Class_C.bar();

    return 0;
}

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

Спасибо,

Джейсон

Я думаю, проблема в том, что при использовании простого наследования между B и A и между C и A вы получаете два объекта типа A в D (каждый из которых будет иметь чисто виртуальную функцию, вызывая ошибку компиляции, потому что D является абстрактным, и вы пытаетесь создать его экземпляр).

Использование виртуального наследования решает проблему, поскольку гарантирует наличие только одной копии A в D.