C ++ dynamic_cast - exigence polymorphe et downcasting

Dans le code suivant, lors de la construction de obj dans le cas 1, nous construisons un derived objet de classe aussi, mais ses fonctions de membre sont tout simplement inaccessibles à obj. Ainsi, alors que de passer (c'est à dire, dans le cas 2), à l'aide de obj comme source, nous avons construit derived dans déjà. Pourquoi obj doivent être polymorphe?

Si j'ai confondu ma description ci-dessus, pourquoi ne pas obj doivent être polymorphe lorsque upcasting, mais tout de passer il ne doivent être polymorphe, tout en utilisant dynamic_cast?

class base
{
public:
    base()
    {
        cout<< " \n base constructor \n";
    }
};

class derived : public base
{
public:
    derived()
    {
        cout << " \n derived constructor \n";
    }
};

base *obj = dynamic_cast<base*> (new derived); //case 1: explicitly upcasting
derived *OBJ = dynamic_cast<derived*> (obj);   //case 2: error

source d'informationauteur Mahesh

  1. 6

    De 5.2.7/1 [expr.dynamique.distribution] :

    Le résultat de l'expression dynamic_cast<T>(v) est le résultat de la conversion de l'expression de v de type
    T.

    [...]

    Si T est "pointeur vers cv1 B" et v est de type "pointeur vers cv2 D" telle que B est une classe de base de D, le résultat est un
    pointeur vers l'unique B sous-objet de la D de l'objet pointé par v.

    [...]

    Sinonv est un pointeur ou une lvalue d'un type polymorphe.

    La norme fournit même l'exemple suivant qui montre que le type polymorphe obligation ne vaut pas pour la dérivée de la base de conversion :

    struct B {};
struct D : B {};
void foo(D* dp)
{
    B* bp = dynamic_cast<B*>(dp); //equivalent to B* bp = dp;
}
  2. 17

    Pour dynamic_cast de travail, l'objet doit être polymorphe. La raison pour cela est que dynamic_cast besoin d'un endroit pour stocker le type d'information qui est à utiliser pour effectuer la distribution, et ce, par le stockage de l'information parallèlement à la vtable pour la classe. Pour qu'il y ait une vtable vous avez besoin de faire au moins un de vos méthodes virtuelles.

    La façon la plus simple de contourner cela est d'drapeau de la classe de base destructeur virtuel.

    Upcasting (c'est à dire provenant à la base) n'a pas besoin d'un plâtre que le compilateur est capable de vérifier que le casting serait de travailler au moment de la compilation. Cependant, ce n'est pas vrai quand passer.

  3. 0

    Dynamic_cast

    • Il est utilisé pour jeter une base de pointeur
      dans un dérivé de pointeur. Si la base
      pointeur ne pointe pas vers un objet de
      le type de la dérivée, il retourne
    • Il est utilisé pour jeter une base de référence
      dans un dérivé de référence. Si l'
      la référence n'est pas en pointant sur un objet
      de la dérivée, il jette
      std::bad_cast.
    • Il peut être considéré comme faisant l'objet d'une fonte
      équivalent à static_cast, en ce qu'il
      vérifie si l'objet pointé
      est vraiment du type dérivé.

    Vous devez en lire plus à propos de Dynamic_cast (avec exemple) il y.

  4. 0
    B* b = new D();
D* d = dynamic_cast<D*>(b);

    Dans l'exemple ci-dessus, la plupart des compilateurs allait mettre en œuvre la dynamique de fonte en vérifiant si la vtable pointeur de b points à la vtable de la classe dérivée D ou pas.
    Si oui, il retourne simplement l'adresse de b comme valeur de retour sinon il renvoie un nullptr.
    C'est ce qui se passe dans les coulisses lors de la dynamique de fonte s'exécute :-

    class car
{
    public:
    virtual void drive()
    {
         std::cout <<"car"<<std::endl;
    }
};
class toyota: public car
{
    public:
    virtual void drive()
    {
        std::cout <<"toyota"<<std::endl;
    }
};

class honda: public car
{
    public:
        virtual void drive()
    {
        std::cout <<"honda"<<std::endl;
    }
};

template <typename Tderived>
Tderived* dynamicCast(void* pBase)
{
    //compare the vptr of the class pointed by pBase with a temporary Tderived class. 
    //If vptr of pBase and vptr of Tderived() are pointing to the same vtable 
    //then it can be safely deduced that pBase is indeed pointing to an instance of Tderived
    if (*(int**)pBase == *(int**)&Tderived())
    {
        return (Tderived*)pBase;
    }
    else
    {
        return nullptr;
    }
}


int main()
{
    car* pCar;
    honda hondaCar;
    toyota toyotaCar;

    pCar = &toyotaCar;

    honda* pHonda = dynamicCast<honda>(pCar);
    if (nullptr != pHonda)
    {
        pHonda->drive();
    }
    else
    {
        toyota* pToyota = dynamicCast<toyota>(pCar);
        if (nullptr != pToyota)
        {
            pToyota->drive();
        }
    }
}

    Maintenant, si la classe n'est pas polymorphe, il n'existe aucun moyen pour le compilateur pour savoir si pCar vers honda ou toyota voiture. Note que ce n'est qu'un des moyens à mettre en œuvre dynamic_cast que la norme C++ ne prend pas en parler rien sur les vtables.