dynamic_cast conversion

Konvertiert sicher Zeiger und Referenzen auf Klassen aufwärts, abwärts und seitwärts entlang der Vererbungshierarchie.

Syntax

Erklärung

Zur Vereinfachung der Beschreibung bedeutet „ expression oder das Ergebnis ist eine Referenz auf T “, dass „es ein Glvalue vom Typ T ist“ , was der Konvention von decltype (seit C++11) folgt.

Nur die folgenden Konvertierungen können mit dynamic_cast durchgeführt werden, außer wenn solche Konvertierungen Constness entfernen würden (oder Volatilität).

Wenn dynamic_cast in einem Konstruktor oder Destruktor verwendet wird (direkt oder indirekt) und expression auf das Objekt verweist, das sich gerade im Konstruktions-/Destruktionsprozess befindet, wird das Objekt als das am stärksten abgeleitete Objekt betrachtet. Wenn target-type kein Zeiger oder keine Referenz auf die eigene Klasse des Konstruktors/Destruktors oder eine seiner Basisklassen ist, ist das Verhalten undefiniert.

Ähnlich wie bei anderen Umwandlungsausdrücken ist das Ergebnis:

Hinweise

Ein Downcast kann auch mit static_cast durchgeführt werden, was die Kosten der Laufzeitprüfung vermeidet, aber nur sicher ist, wenn das Programm garantieren kann (durch andere Logik), dass das Objekt, auf das expression zeigt, definitiv Derived ist.

Einige Formen von dynamic_cast basieren auf Laufzeit-Typinformation (RTTI), also Informationen über jede polymorphe Klasse im kompilierten Programm. Compiler bieten typischerweise Optionen zum Deaktivieren der Einbindung dieser Informationen.

Schlüsselwörter

dynamic_cast

Beispiel

#include <iostream>
struct V
{
    virtual void f() {} // muss polymorph sein, um dynamische Typumwandlung zur Laufzeit zu verwenden
};
struct A : virtual V {};
struct B : virtual V
{
    B(V* v, A* a)
    {
        // Typumwandlungen während der Konstruktion (siehe Aufruf im Konstruktor von D unten)
        dynamic_cast<B*>(v); // wohldefiniert: v vom Typ V*, V Basis von B, ergibt B*
        dynamic_cast<B*>(a); // undefiniertes Verhalten: a hat Typ A*, A keine Basis von B
    }
};
struct D : A, B
{
    D() : B(static_cast<A*>(this), this) {}
};
struct Base
{
    virtual ~Base() {}
};
struct Derived : Base
{
    virtual void name() {}
};
int main()
{
    D d; // das am meisten abgeleitete Objekt
    A& a = d; // Upcast, dynamic_cast könnte verwendet werden, aber unnötig
    [[maybe_unused]]
    D& new_d = dynamic_cast<D&>(a); // Downcast
    [[maybe_unused]]
    B& new_b = dynamic_cast<B&>(a); // Sidecast
    Base* b1 = new Base;
    if (Derived* d = dynamic_cast<Derived*>(b1); d != nullptr)
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // sicher aufzurufen
    }
    Base* b2 = new Derived;
    if (Derived* d = dynamic_cast<Derived*>(b2); d != nullptr)
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // sicher aufzurufen
    }
    delete b1;
    delete b2;
}

downcast from b2 to d successful

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch

• const_cast
• static_cast
• reinterpret_cast
• explizite Konvertierung
• implizite Konvertierungen