Wie identifiziert man fehlgeschlagene Casts mit dem dynamic_cast Operator?

Question

Scott Meyer in seinem Buch Effective C++ sagt dynamic_cast wird verwendet, um sichere Casts nach unten oder über eine Vererbungshierarchie durchzuführen. Das heißt, Sie verwenden dynamic_cast, um Zeiger oder Verweise auf Basisklassenobjekte in Zeiger oder Verweise auf abgeleitete oder gleichgeordnete Basisklassenobjekte zu konvertieren, sodass Sie feststellen können, ob die Umwandlungen erfolgreich waren.

Fehlgeschlagene Umwandlungen werden durch einen Null-Zeiger (beim Umwandeln von Zeigern) oder eine Ausnahme (beim Umwandeln von Referenzen) angezeigt.

Ich möchte zwei Code-Snippet bekommen, die die fehlgeschlagene Besetzung im Fall von Casting-Pointer und Casting-Referenz angezeigt werden kann.

Answer 1

für Zeiger, es ist ein einfacher Null-Check:

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

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

Für Referenzen, können Sie fangen:

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

Answer 2

auf der Bemerkung des OP Basierend (“Ich verstehe nicht, wie Abgüsse ausfallen könnten als von Scott erwähnt. "), die eigentliche Frage hier ist wirklich etwas wie:" Wie könnte ein dynamic_cast scheitern? "

Die Zeit, die es fehlschlagen würde, wenn der Zieltyp nicht mit dem dynamischen Typ des Objekts übereinstimmt. Ein einfaches Beispiel:

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; 
} 

Hier obwohl akonnte Punkt auf ein Objekt vom Typ B, es tatsächlich tut Punkt auf ein Objekt vom Typ A. Wenn wir versuchen, eine dynamic_cast zu machen, um es auf eine B zu zeigen, schlägt das fehl. Im zweiten Versuch haben wir wieder einen Zeiger, der nicht nur sondern auf ein Objekt des Typs B zeigen konnte. Da dies der Fall ist, gelingt in diesem Fall der dynamic_cast zu B *.

Die Grundsituation ändert sich nicht (viel) für den Referenzfall, nur a, b und c werden Referenzen anstelle von Zeigern, und wir beachten Sie den Fehler durch eine Ausnahme zu kontrollieren (die @ReedCopsey bereits gut genug gezeigt, dass Ich glaube nicht, dass ich etwas Neues hinzuzufügen habe).

Answer 3

Hier ist ein vollständiges Beispiel, das zeigt, wie dynamic_cast einen Zeiger nicht erzeugen kann.

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 
} 

In der realen Welt werden versuchen, Sie Zeiger zu werfen, die nicht so ohne weiteres erstellt wurden, vielleicht kommen sie von einem vector zum Beispiel.