Mehrfachvererbung casting von der Basis-Klasse für verschiedene abgeleitete Klasse

Keine. Ist dies nicht möglich (direkte Umwandlung von A* zu B*).

Weil die Adresse A und B sind an verschiedenen Standorten in der class C. Also der cast wird immer unsicherer und möglicherweise könnten Sie landen in unerwartetes Verhalten. Demo.

Dem Gießen sollte immer über class C. z.B.

A* pa = new C();
B* pb = static_cast<C*>(pa);
                   ^^^^ go through class C

Demo

Ja, sollten Sie zuerst static_cast Objekt zu C* ist, dann können Sie static_cast es wieder zu B (obwohl diese Letzte cast ist auch nicht nötig, da ist eine standard-Konvertierung). Ich bin mir nicht sicher, ob static_casting Objekt direkt an B würde funktionieren, versuchen Sie es und sehen, ob man compiler-Fehler. reinterpret_casting Objekt B erhalten Sie eine Laufzeit-crash, da A und B haben unterschiedliche Adressen, wenn Sie beide nicht leer sind.

Bearbeiten Nachdem Sie die Frage, ist es nicht mehr möglich, das zu tun, was Sie wollen. Sie müssen wissen, die richtige Pfad, oben und unten im vererbungsbaum, als casting in einem Szenario mit Mehrfachvererbung mit nicht-leeren Klassen impliziert Verschiebungen in den Zeiger.

Natürlich, können Sie. Logisch, wenn du definitiv sicher, dass ein Objekt X ist der Typ von A, dann bedeutet es, Sie können es verwenden, wie A.

Die einfache und naive Art und Weise dies zu erreichen ist die Verwendung von dynamic_cast, zur Verfügung gestellt von der standard-C++. Es wird jedoch lineare Zeit, sich in der vtable, weil dynamic_cast überprüfen, ob der angegebene Zeiger ist eigentlich extrem weit geworfen werden kann, um die vorliegende Art, nicht wie Ihr, die bereits wissen, dass X Typ A. Einige Plattformen können einfach nicht liefern, RTTI, die Sie tun können, dynamic_cast.

Es gibt eine andere Lösung: lassen Sie sich von den A-und B weiß, dass selbst eine Oberklasse davon ist multiple Vererbung.

#include <iostream>
#include <string>

struct Widget
{
    virtual ~Widget() = default;

    double widgetData;
};

struct DbItem
{
    virtual ~DbItem() = default;

    std::string nodeData;
};

struct GeneralItem
{
    virtual ~GeneralItem() = default;

    virtual void* cast(int type) = 0;
// virtual void const* cast(int type) const = 0; //Use this as well

    //This is alternative for someone who don't like
    //dynamic function!
    void* ptrOfWidgetOrDbNode;

    //If GeneralItem can know what it can be casted to.
// virtual Widget* toWidget() = 0;
// virtual DbItem* toDbItem() = 0;
};

enum { Widget_id, DbItem_id };

//Can be used as syntax candy.
Widget* toWidget(GeneralItem* gItem)
{
    return static_cast<Widget*>(gItem->cast(Widget_id));
}
DbItem* toDbItem(GeneralItem* gItem)
{
    return static_cast<DbItem*>(gItem->cast(DbItem_id));
}

struct TextView : Widget, GeneralItem
{
    TextView() { widgetData = 20.0; }
    void* cast(int type) override
    {
        switch ( type )
        {
            //WARNING: static_cast IS MANDATORY.
            case Widget_id: return static_cast<Widget*>(this);
            default: return nullptr;
        }
    }
};

struct ImageView : GeneralItem, Widget
{
    ImageView() { widgetData = 40.0; }
    void* cast(int type) override
    {
        switch ( type )
        {
            //WARNING: static_cast IS MANDATORY.
            case Widget_id: return static_cast<Widget*>(this);
            default: return nullptr;
        }
    }
};

struct SoundData : DbItem, GeneralItem
{
    SoundData() { nodeData = "Sound"; }
    void* cast(int type) override
    {
        switch ( type )
        {
            //WARNING: static_cast IS MANDATORY.
            case DbItem_id: return static_cast<DbItem*>(this);
            default: return nullptr;
        }
    }
};

struct VideoData : GeneralItem, DbItem
{
    VideoData() { nodeData = "Video"; }
    void* cast(int type) override
    {
        switch ( type )
        {
            //WARNING: static_cast IS MANDATORY.
            case DbItem_id: return static_cast<DbItem*>(this);
            default: return nullptr;
        }
    }
};

GeneralItem* getDbItem();
GeneralItem* getWidget();

int main()
{
    {
        //This is definitely subclass of Widget, but
        //GeneralItem has no relationship with Widget!
        GeneralItem* gItem = getWidget();
        Widget* nowWidget = static_cast<Widget*>(gItem->cast(Widget_id));
        std::cout << nowWidget->widgetData << std::endl;
        delete gItem;
    }

    {
        //This is definitely DbItem!
        GeneralItem* gItem = getDbItem();
//     DbItem* nowDbItem = static_cast<DbItem*>(gItem->cast(DbItem_id));
        //You can use sugar!
        DbItem* nowDbItem = toDbItem(gItem);
        std::cout << nowDbItem->nodeData << std::endl;
        delete gItem;
    }
}

GeneralItem* getDbItem()
{
    return new VideoData;
}

GeneralItem* getWidget()
{
    return new TextView;
}

In diesem Beispiel-code, es gibt 3 Basis-Klassen, 2 getter-Funktionen, und einige Unterklassen. Widget und DbItem sind Klassen, die Sie nicht berühren können, und GeneralItem dient als Oberklasse für die Klassen, die mehrfache Vererbung.

getDbItem() : GeneralItem* ist eine Funktion, die zurückgibt, GeneralItem, das ist definitiv Instanz DbItem als gut. getWidget() : GeneralItem* ist ähnlich wie einer, der Typ des zurückgegebenen Instanz muss-Widget.

GeneralItem hat eine virtuelle Funktion cast(type_id) : void* gibt Zeiger vom angegebenen Typ, aber im void-Zeiger bilden, weil Rückgabetyp ist bestimmt in der Kompilierung. Es kann gegossen werden zurück zu der Art, die Sie wollen, indem static_cast oder reinterpret_cast: jeder kann verwendet werden.

Müssen Sie darauf achten, bei beliebiger Reihenfolge der Oberklassen und static_cast in cast() Umsetzung: wenn Sie verpassen, static_cast, Ihre void-Zeiger zugeordnet werden Kind-Klasse, nicht genau DbItem oder Widget. Weglassen static_cast wird es ermöglichen, dass Sie sauber, auch ohne Warnung kompilieren, das Ergebnis, da wirft einen typisierten Zeiger auf void-Zeiger ist ganz vernünftig.

Dies ist nur eine Lösung unter den verschiedenen Möglichkeiten, also, wenn Sie sind auf der Suche nach einer Lösung, die verwendet werden können, in verschiedenen Situationen, lassen Sie es mich bitte wissen.

Mein Englisch ist nicht so gut, und möglicherweise gibt es einige Grammatik-Fehler in den Kontext.