C++
RTTI: runtime-type-informatie

Naam van een type

U kunt de door de implementatie gedefinieerde naam van een type in runtime ophalen met behulp van de .name() std::type_info object std::type_info geretourneerd door typeid .

#include <iostream>
#include <typeinfo>

int main()
{
    int speed = 110;

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

Output (door de implementatie gedefinieerd):

int

dynamic_cast

Gebruik dynamic_cast<>() als een functie, waarmee u door een overervingshiërarchie kunt bladeren ( hoofdbeschrijving ).

Als je wat niet-polymorf werk moet verrichten op sommige afgeleide klassen B en C , maar de basisklasse class A , schrijf dan als volgt:

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

Het typide trefwoord

Het sleutelwoord typeid is een unaire operator die runtime-type-informatie geeft over de operand als het type operand een polymorf type is. Het retourneert een waarde van type const std::type_info . Cv-kwalificatie op het hoogste niveau wordt genegeerd.

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

typeid kan ook rechtstreeks op een type worden toegepast. In dit geval worden de eerste referenties op het hoogste niveau verwijderd en wordt de cv-kwalificatie op het hoogste niveau genegeerd. Het bovenstaande voorbeeld had dus met typeid(Derived) kunnen worden geschreven in plaats van typeid(Derived{}) :

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

Als typeid wordt toegepast op een expressie die niet van het polymorfe klasse-type is, wordt de operand niet geëvalueerd en is de geretourneerde type-informatie van het statische type.

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

Wanneer gebruik je welke cast in c ++

Gebruik dynamic_cast voor het converteren van pointers / referenties binnen een overervingshiërarchie.

Gebruik static_cast voor gewone typeconversies .

Gebruik reinterpret_cast voor herinterpretatie van bitpatronen op laag niveau. Gebruik met uiterste voorzichtigheid.

Gebruik const_cast om const / volatile weg te werpen. Vermijd dit tenzij u vastloopt met een const-incorrecte API.