C++
RTTI: Informations sur le type d'exécution

Nom d'un type

Vous pouvez récupérer le nom d'un type défini par l'implémentation à l'exécution en utilisant la fonction membre .name() de l'objet std::type_info renvoyé par typeid .

#include <iostream>
#include <typeinfo>

int main()
{
    int speed = 110;

    std::cout << typeid(speed).name() << '\n';
}

Sortie (définie par la mise en œuvre):

int

dynamic_cast

Utilisez dynamic_cast<>() comme une fonction qui vous aide à passer à travers une hiérarchie d'héritage ( description principale ).

Si vous devez effectuer un travail non polymorphe sur certaines classes dérivées B et C , mais avez reçu la class A base class A , écrivez comme ceci:

class A { public: virtual ~A(){} };

class B: public A
{ public: void work4B(){} };

class C: public A
{ public: void work4C(){} };

void non_polymorphic_work(A* ap)
{
  if (B* bp =dynamic_cast<B*>(ap))
    bp->work4B(); 
  if (C* cp =dynamic_cast<C*>(ap))
    cp->work4C(); 
}

Le mot-clé de typeid

Le mot - clé typeid est un opérateur unaire qui fournit des informations sur le type d'exécution de son opérande si le type de l'opérande est un type de classe polymorphe. Il retourne une lvalue de type const std::type_info . La qualification cv de niveau supérieur est ignorée.

struct Base {
    virtual ~Base() = default;
};
struct Derived : Base {};
Base* b = new Derived;
assert(typeid(*b) == typeid(Derived{})); // OK

typeid peut également être appliqué directement à un type. Dans ce cas, les premières références de niveau supérieur sont supprimées, puis la qualification cv de niveau supérieur est ignorée. Ainsi, l'exemple ci-dessus aurait pu être écrit avec typeid(Derived) au lieu de typeid(Derived{}) :

assert(typeid(*b) == typeid(Derived{})); // OK

Si typeid est appliqué à toute expression qui n'est pas de type de classe polymorphe, l'opérande n'est pas évalué et les informations de type renvoyées sont pour le type statique.

struct Base {
    // note: no virtual destructor
};
struct Derived : Base {};
Derived d;
Base& b = d;
assert(typeid(b) == typeid(Base)); // not Derived
assert(typeid(std::declval<Base>()) == typeid(Base)); // OK because unevaluated

Quand utiliser qui jette en c ++

Utilisez dynamic_cast pour convertir les pointeurs / références dans une hiérarchie d'héritage.

Utilisez static_cast pour les conversions de type ordinaire.

Utilisez reinterpret_cast pour une réinterprétation de bas niveau des modèles de bits. Utilisez avec une extrême prudence.

Utilisez const_cast pour jeter const / volatile. Évitez ceci à moins que vous soyez bloqué en utilisant une API const-incorrecte.