Come identificare i cast falliti usando l'operatore dynamic_cast?

Question

Scott Meyer nel suo libro Effective C++ dice dynamic_cast viene utilizzato per eseguire calcoli di sicurezza verso il basso o attraverso una gerarchia di ereditarietà. Cioè, tu usi dynamic_cast per eseguire il cast di puntatori o riferimenti a oggetti di classe base in puntatori o riferimenti a oggetti di classe di base derivati ​​o fratelli in modo tale che tu possa determinare se i cast sono riusciti.

Le conversioni non riuscite sono indicate da un puntatore nullo (quando si esegue il cast dei puntatori) o un'eccezione (quando si esegue il cast dei riferimenti).

Vorrei ottenere due frammenti di codice che mostrano il cast fallito in caso di puntatore di lancio e il riferimento di casting può essere indicato.

Answer 1

Per puntatori, si tratta di un semplice controllo nullo:

A* a = new A(); 
B* b = dynamic_cast<B*>(a); 

if (b == NULL) 
{ 
    // Cast failed 
} 

Per i riferimenti, si può prendere:

try { 
    SomeType &item = dynamic_cast<SomeType&>(obj); 
} 
catch(const std::bad_cast& e) { 
    // Cast failed 
} 

Answer 2

Basato sul commento del PO (" Io non capisco come calchi potrebbero fallire come citato da Scott. "), la vera domanda qui è veramente qualcosa del tipo:" come potrebbe un dynamic_cast fallire? "

Il tempo in cui si verifica un errore è quando il tipo di destinazione non corrisponde al tipo dinamico dell'oggetto. Per un semplice esempio:

struct A { 
    virtual ~A() {} 
}; 

class B : public A {}; 

int main() { 
    A *a = new A; 

    B *b = dynamic_cast<B *>(a); // should fail 
    if (b == NULL) 
     std::cout << "First cast failed.\n"; 

    A *c = new B; 
    b = dynamic_cast<B *>(c);  // should succeed 
    if (b == NULL) 
     std::cout << "Second cast failed.\n"; 
    return 0; 
} 

Qui sebbene apotrebbe scegliere un oggetto di tipo B, in realtà fa scegliere un oggetto di tipo A. Quando proviamo a fare un dynamic_cast per farlo puntare a un B, questo fallisce. Nel secondo tentativo, abbiamo di nuovo un puntatore che non solo potrebbe ma fa puntare a un oggetto di tipo B. Dal momento che lo fa, il dynamic_cast a B * riesce in questo caso.

La situazione di base non cambia (molto) per il caso di riferimento, solo a, b e c diventano riferimenti al posto dei puntatori, e notiamo il fallimento con la cattura un'eccezione (che @ReedCopsey ha già dimostrato abbastanza bene che Non penso di avere nulla di nuovo da aggiungere).

Answer 3

Ecco un esempio completo che mostra come dynamic_cast non può produrre un puntatore.

class A 
{ 
public: 
    virtual void Foo(); 
}; 

class B: public A 
{ 
}; 

class C: public A 
{ 
}; 

void test() 
{ 
    A a; 
    B b; 
    A* pA = &b; 
    B* pB = dynamic_cast<B*>(pA); // this works OK, returns the expected pointer 
    C* pC = dynamic_cast<C*>(pA); // this returns NULL because B isn't a C 
} 

Nel mondo reale sarete tentando di lanciare puntatori che non sono stati così creati semplicemente, forse provengono da un vector per esempio.