typeid, opérateur

Syntaxe

typeid(type-id)
typeid(expression)

Notes

L'opérateur typeid permet de déterminer le type d'un objet au moment de l'exécution.

Le résultat de typeid est un const type_info&. La valeur est une référence à un objet type_info qui représente l’id de type ou le type de l’expression, selon la forme de typeid utilisée. Pour plus d’informations, consultez Classe type_info.

L’opérateur typeid ne fonctionne pas avec les types managés (déclarateurs abstraits ou instances abstraites). Pour plus d’informations sur l’obtention du Type d’un type spécifié, consultez typeid.

L'opérateur typeid effectue un contrôle à l'exécution lorsqu'il est appliqué à une valeur l-value d’un type de classe polymorphe, où le type réel de l'objet ne peut pas être déterminé par les informations statiques fournies. Dans les cas suivants par exemple :

• Une référence à une classe

• Un pointeur, déréférencé avec *

• Un pointeur indicé ([ ]). (il n'est pas sûr d’utiliser un indice avec un pointeur vers un type polymorphe.)

Si l'expression pointe vers un type classe de base, l'objet est en fait d'un type dérivé de cette classe de base, une référence type_info de la classe dérivée est le résultat. L'expression doit pointer vers un type polymorphe (une classe avec des fonctions virtuelles). Sinon, le résultat est type_info pour la classe statique référencée dans l'expression. De plus, le pointeur doit être déréférencé afin que l’objet utilisé soit celui auquel il pointe. Si le pointeur n'est pas déréférencé, le résultat sera le type_info du pointeur, et pas ce qu'il désigne. Par exemple :

// 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;
}

Si l’expression déréférence un pointeur, et que cette valeur du pointeur est zéro, typeid lève une exception bad_typeid. Si le pointeur ne pointe pas vers un objet valide, une exception __non_rtti_object est levée. Cela indique une tentative d’analyse du RTTI qui a déclenché une erreur, car l’objet n’est en quelque sorte pas valide. (Par exemple, il s’agit d’un pointeur incorrect ou le code n’a pas été compilé avec /GR).

Si l’expression n’est pas un pointeur ni une référence à une classe de base de l’objet, le résultat est une référence type_info représentant le type statique de l’expression. Le type statique d’une expression fait référence au type d’une expression tel qu’il est connu au moment de la compilation. Les sémantiques d'exécution sont ignorées en évaluant le type statique d'une expression. De plus, les références sont ignorées si possible lors de la détermination du type statique d'une expression :

// expre_typeid_Operator_2.cpp
#include <typeinfo>

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

typeid peut également être utilisé dans des modèles pour déterminer le type d'un paramètre de modèle :

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

Voir aussi

Informations de type au moment de l’exécution
Mots clés