C ++ dynamic_cast - Exigence polymorphe et Downcasting

dynamic_cast

• il est utilisé pour lancer un pointeur de base dans un pointeur dérivé. Si la base le pointeur ne pointe pas vers un objet de Le type de dérivé, il retourne
• il est utilisé pour lancer une référence de base dans une référence dérivée. Si la référence ne pointe pas à un objet du dérivé, il jette STD :: Bad_cast.
• Il peut être considéré comme le casting vérifié équivalent à static_cast, en ce qu'il vérifie si l'objet pointé vers est vraiment du type dérivé.

  Vous devez en savoir plus sur dynamic_cast (avec exemple) Il .

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