Operatore typeid

Sintassi

typeid(type-id)
typeid(expression)

Osservazioni:

L'operatore typeid consente di determinare il tipo di un oggetto in fase di esecuzione.

Il risultato di typeid è un oggetto const type_info&. Il valore è un riferimento a un type_info oggetto che rappresenta l'ID di tipo o il tipo dell'espressione, a seconda della forma utilizzatatypeid. Per altre informazioni, vedere classe type_info.

L'operatore typeid non funziona con i tipi gestiti (dichiaratori astratti o istanze). Per informazioni su come ottenere l'oggetto Type di un tipo specificato, vedere typeid.

L'operatore typeid esegue un controllo in fase di esecuzione quando viene applicato a un valore l di un tipo di classe polimorfica, in cui il tipo true dell'oggetto non può essere determinato dalle informazioni statiche fornite. I casi sono i seguenti:

• Un riferimento a una classe

• Puntatore, dereferenziato con *

• Puntatore pedice ([ ]). Non è sicuro usare un pedice con un puntatore a un tipo polimorfico.

Se l'espressione punta a un tipo di classe base, ma l'oggetto è effettivamente di un tipo derivato da tale classe base, un type_info riferimento per la classe derivata è il risultato. L'espressione deve puntare a un tipo polimorfico (una classe con funzioni virtuali). In caso contrario, il risultato è per type_info la classe statica a cui fa riferimento nell'espressione. Inoltre, il puntatore deve essere dereferenziato in modo che l'oggetto usato sia quello a cui punta. Senza dereferenziare il puntatore, il risultato sarà per type_info il puntatore, non a quello a cui punta. Ad esempio:

// expre_typeid_Operator.cpp
// compile with: /GR /EHsc
#include <iostream>
#include <typeinfo>

class Base {
public:
   virtual void vvfunc() {}
};

class Derived : public Base {};

using namespace std;
int main() {
   Derived* pd = new Derived;
   Base* pb = pd;
   cout << typeid( pb ).name() << endl;   //prints "class Base *"
   cout << typeid( *pb ).name() << endl;   //prints "class Derived"
   cout << typeid( pd ).name() << endl;   //prints "class Derived *"
   cout << typeid( *pd ).name() << endl;   //prints "class Derived"
   delete pd;
}

Se l'espressione dereferenzia un puntatore e il valore del puntatore è zero, typeid genera un'eccezione bad_typeid. Se il puntatore non punta a un oggetto valido, viene generata un'eccezione __non_rtti_object . Indica un tentativo di analizzare l'RTTI che ha attivato un errore perché l'oggetto non è in qualche modo valido. Ad esempio, si tratta di un puntatore non valido o il codice non è stato compilato con /GR.

Se l'espressione non è un puntatore e non un riferimento a una classe base dell'oggetto, il risultato è un type_info riferimento che rappresenta il tipo statico dell'espressione. Il tipo statico di un'espressione fa riferimento al tipo di un'espressione così come è noto in fase di compilazione. Durante la valutazione del tipo statico di un'espressione, la semantica di esecuzione viene ignorata. Inoltre, i riferimenti vengono, quando possibile, ignorati durante la determinazione del tipo statico di un'espressione.

// expre_typeid_Operator_2.cpp
#include <typeinfo>

int main()
{
   typeid(int) == typeid(int&); // evaluates to true
}

typeid può essere usato anche nei modelli per determinare il tipo di parametro di un modello:

// expre_typeid_Operator_3.cpp
// compile with: /c
#include <typeinfo>
template < typename T >
T max( T arg1, T arg2 ) {
   cout << typeid( T ).name() << "s compared." << endl;
   return ( arg1 > arg2 ? arg1 : arg2 );
}

Vedi anche

Informazioni sui tipi di runtime
Parole chiave