Comment identifier les distributions ayant échoué en utilisant l'opérateur dynamic_cast?

Scott Meyer dans son livre Effective C++ dit dynamic_cast est utilisé pour effectuer sûr jette vers le bas ou à l'ensemble d'une hiérarchie d'héritage. Qui est, vous utilisez dynamic_cast pour lancer des pointeurs ou des références à la classe de base d'objets dans des pointeurs ou des références à des dérivés, frère ou sœur de la classe de base des objets de telle façon que vous pouvez déterminer si le jette réussi.

Échec de moulages sont indiqués par un pointeur null (lors de la coulée des pointeurs) ou d'une exception (lors de la coulée des références).

Je voudrais obtenir deux extrait de code montrant l'échec de la fonte dans le cas de la coulée de pointeur et de la coulée de référence peut être indiqué.

source d'informationauteur nitin_cherian

  1. 23

    Pour les pointeurs, c'est un simple null check:

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

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

    Pour les références, vous pouvez vous rattraper:

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

    Basé sur l'OP du commentaire (" je ne comprends pas comment jette pourrait échouer, comme mentionné par Scott."), la vraie question ici est vraiment quelque chose comme: "comment un dynamic_cast échec?"

    Le temps qu'il échoue, c'est quand le type de cible ne correspond pas au type dynamique de l'objet. Pour un exemple simple:

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

    Ici, bien que a pourrait point à un objet de type Bil fait ne point à un objet de type A. Lorsque nous essayons de faire un dynamic_cast pour l'obtenir à point à un Bqui échoue. Dans le deuxième essai, nous avons à nouveau un pointeur qui pourrait non seulement mais ne point à un objet de type B. Depuis qu'il fait, le dynamic_cast pour B * réussit dans ce cas.

    La situation de base ne change pas (beaucoup) pour le cas de référence, juste ab et c devenus des références à la place des pointeurs, et l'on constate l'échec par l'interception d'une exception (@ReedCopsey a déjà démontré assez bien ce que je ne pense pas que j'ai quelque chose de nouveau à ajouter).

  3. 3

    Voici un exemple complet qui montre comment dynamic_cast peut échouer à produire un pointeur.

    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
}

    Dans le monde réel, vous serez en train de jeter des pointeurs qui n'étaient pas carrément créé, peut-être qu'ils viennent d'un vector par exemple.