Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

dynamic_cast — conversione verificata nelle gerarchie di classi

dynamic_cast converte puntatori e riferimenti all’interno delle gerarchie di classi, verificando a runtime le conversioni che lo richiedono. Se una conversione di puntatore non riesce, restituisce nullptr; se non riesce una conversione di riferimento, genera std::bad_cast.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

dynamic_cast<T>(expression)

dynamic_cast<T>(expression) converte puntatori o riferimenti all’interno delle gerarchie di classi. T deve essere un puntatore o un riferimento a un tipo classe completo, oppure un puntatore a void, con eventuali qualificatori cv. L’operatore non può rimuovere i qualificatori const o volatile.

Le conversioni verso il basso a classi derivate e le conversioni incrociate tra rami di ereditarietà richiedono un tipo sorgente polimorfico: una classe con almeno una funzione virtuale. L’esito dipende dall’oggetto effettivo e dalle regole di ereditarietà pubblica e non ambigua. Una conversione verso l’alto a una classe base accessibile e non ambigua non richiede polimorfismo; di solito è sufficiente una conversione implicita.

Se il controllo di un puntatore non riesce, il risultato è nullptr; se non riesce quello di un riferimento, viene generato std::bad_cast, dichiarato in <typeinfo>. Un puntatore di input nullo produce un puntatore risultato nullo. La conversione a un puntatore a void richiede che il tipo statico a cui punta p sia polimorfico. Se p non è nullo, il risultato punta all’oggetto più derivato. Il tipo puntato dal risultato deve conservare gli eventuali qualificatori const e volatile del tipo puntato da p. Per esempio, se p punta a un tipo polimorfico qualificato const ma non volatile, si usa dynamic_cast<const void*>(p) anziché dynamic_cast<void*>(p). L’operatore non verifica i puntatori pendenti: violare i requisiti relativi alla durata di vita dell’oggetto può causare comportamento indefinito.

L’esempio mostra un caso riuscito e le due forme di errore. È destinato a C++23; l’URL dello standard fornito rimanda a una bozza in evoluzione, non a una pubblicazione definitiva di C++23. L’esempio è stato eseguito in un ambiente isolato; non ne è attestata l’esecuzione in produzione.

Esempi

#include <iostream>
#include <typeinfo>

struct Base {
    virtual ~Base() = default;
};

struct Derived : Base {
    int value = 42;
};

int main() {
    Derived derived;
    Base base;
    Base* good = &derived;
    Base* other = &base;

    if (auto* p = dynamic_cast<Derived*>(good)) {
        std::cout << p->value << '\n';
    }
    std::cout << std::boolalpha
              << (dynamic_cast<Derived*>(other) == nullptr) << '\n';

    try {
        (void)dynamic_cast<Derived&>(*other);
    } catch (const std::bad_cast&) {
        std::cout << "bad_cast\n";
    }
}

Risultato

42
true
bad_cast

Il codice mostrato è stato eseguito senza modifiche in un ambiente isolato. Il suo output standard (`stdout`) corrispondeva esattamente a quello indicato.

Fonti