Mam trudny okres z przerażającym problemem z diamentami. Dla przypomnienia, oto klasyczna hierarchia klas tego problemu:

<code>    B
   / \
 C1   C2
   \ /
    D
</code>

Aby rozwiązać ten problem, standardowym rozwiązaniem jest użycie w C1 i C2 dziedziczenia wirtualnego w celu dziedziczenia z B.

Moim problemem jest to, że B i C1 pochodzą z SDK, którego nie mogę modyfikować. Przykład poniżej, gdzie nie mogę zrobićSubClassB dziedziczyć wirtualnie zBaza. Klasy: PureVirtualBase, Base i SubClassB pochodzą z SDK, którego używam. Nie mogę ich modyfikować. SubClassA i Leaf to moje niestandardowe klasy. Mogę je zmienić.

<code>     PureVirtualBase(SDK)
           |
        Base(SDK)
       /        \
 SubClassA   SubClassB(SDK)
       \        /
          Leaf
</code>

W takiej sytuacji gdzieSubClassB nie można zmienić, aby użyć wirtualnego dziedziczenia zBaza. Jak to powinno wyglądać:

Liść instancja zawiera tylko jedenBazaUnikaj dwuznaczności podczas próby uzyskania dostępu do funkcji zdefiniowanych jako wirtualnyPureVirtualBase i wdrożone wBaza

<code>class PureVirtualBase
{
public:
    PureVirtualBase()
    {
        cout<<"<<PureVirtualBase::PureVirtualBase" << endl;
        cout<<">>PureVirtualBase::PureVirtualBase" << endl;
    }
    virtual int f_PureVirtualBase()=0;
};
class Base : public PureVirtualBase
{
public:
    Base(std::string id) {
        cout<<"<<Base::Base:"<<id << endl;
        m_id=id;
        cout<<">>Base::Base:"<<m_id << endl;
    }
    virtual int f_PureVirtualBase() {
       cout<<"Base::f_PureVirtualBase" << endl;
       return 1;
    }
private:
    std::string m_id;
};
class SubClassA:  public virtual Base
{
public:
    SubClassA(): Base("From SubClassA") {
        cout<<"<<SubClassA::SubClassA" << endl;
        cout<<">>SubClassA::SubClassA" << endl;
    }
};
class SubClassB:  public Base
{
public:
    SubClassB():Base("From SubClassB") {
        cout<<"<<SubClassB::SubClassB" << endl;
        cout<<">>SubClassB::SubClassB" << endl;
    }
};    
class Leaf:  public SubClassA, public SubClassB
{
public:
    Leaf():SubClassA(),  SubClassB(), Base("From Leaf") {
        cout << "<<Leaf::Leaf" << endl;
        cout << ">>Leaf::Leaf"<< endl;
    }
};
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Leaf myleaf;
    myleaf.f_PureVirtualBase();
    return a.exec();
}
</code>

Jeśli skomentuję wywołanie f_PurevirtualBase, kompiluje się, ale mam ostrzeżeniewirtualna baza „Baza” niedostępna w „Liście” z powodu niejasności Jeśli odkomentuję to połączenie: otrzymuję ten błąd:żądanie dla członka „f_PureVirtualBase” jest niejednoznaczneJeśli poprzedzę to wywołanie nazwą klasy (myleaf.SubClassA :: f_PureVirtualBase (), to działa, ale coś jest oczywiście błędne, ponieważ są 2Baza zawarte wLiść Obiekt).

Jakaś podpowiedź?

Więcej informacji, aby odpowiedzieć na komentarze

Moja docelowa architektura jest nieco bardziej skomplikowana niż próbka podana w pierwotnym pytaniu:

<code> PureVirtualBase(SDK)
       |
     Base(SDK)
        |
        --SubClassA
        --SubClassB(SDK)
        --SubClassC(SDK)
        --SubClassD(SDK)
</code>

LeafOne: dziedziczy po SubClassA i SubClassB (SDK)

LeafTwo: dziedziczy po SubClassA i SubClassC (SDK)

LeafThree: dziedziczy z SubClassA i SubClassD (SDK)

SubClassA to mój prywatny kod. Zapewnia funkcje niestandardowe. Powinien być w stanie traktować jak instancję Base metodami SDK. Ta klasa nie zostanie utworzona, ale jest tutaj, aby móc obsługiwać LeafOne, LeafTwo i LeafThree podczas wykonywania niektórych zabiegów.