Page de garde C++ Le RTTI et les opérateurs de cast Maîtrise dinformatique Février 2002

Le RTTI Le Run-Time Type Information (RTTI) Si la classe B étend la classe A, alors dans lexpression A * ptr= new B(); A* est le type statique de ptr, information que le compilateur conserve. B* est le type dynamique de ptr, information que le compilateur "oublie". Comment connaître le type dynamique de ptr à lexécution ?

Le RTTI Le Run-Time Type Information (RTTI) Solution à la main : class A {... virtual bool IsB() const { return false );... } class B: public A {... virtual bool IsB() const { return true );... } Implémentation fastidieuse et source potentielle derreurs. Implique de mettre à jour la classe racine lors de lajout de classes dérivées. Encombrement de la table des méthodes virtuelles. Exécution a priori très rapide.

Le RTTI Le Run-Time Type Information (RTTI) Solution C++ : le RTTI ! #include const type_info& typeid( expression_or_type ) /** égalité/inégalité stricte */ int type_info::operator==( const type_info& rhs ) const; int type_info::operator!=( const type_info& rhs ) const; /** nom human-readable */ const char * type_info::name() const; /** nom interne */ const char * type_info::raw_name() const; /** collating order (aucune indication hiérarchique !) */ int type_info::before( const type_info& rhs ) const;

Le RTTI Le Run-Time Type Information (RTTI) class A {... }; class B: public A {... }; const A * const a= new A(); const B * const b= new B(); typeid( a ).name() "class A const *" ????? const ????? typeid( *a ).name() "class A" ????? const ????? typeid( a ) == typeid( a ) true typeid( a ) == typeid( b ) false

Le RTTI Le Run-Time Type Information (RTTI) Attention : lutilisation de typeid sur des classes non polymorphes (i.e. sans fonctions virtuelles) pourrait renvoyer le type statique… Pour pouvoir utiliser typeid sur toutes les classes, il est nécessaire de forcer le compilateur à ajouter des informations de type dynamique aussi sur les classes classes non polymorphes : Visual C++ : /GR ou Project | Settings | C/C++ | C++ Language | Enable RTTI g++ : ?????????? Pensez à déréférencer les pointeurs pour obtenir des informations sur le type de lobjet pointé, et pas sur le type du pointeur ! Si ptr est 0/NULL, typeid( *ptr ) lance lexception std::bad_typeid.

Les opérateurs de cast 4 opérateurs de cast : reinterpret_cast aucune vérification static_cast vérification statique de plausibilité (downcast) dynamic_cast vérification dynamique (downcast) const_cast pour enlever const et/ou volatile Syntaxe générale : xxxxx_cast ( expression )

reinterpret_cast Correspond au cast de C (aucune vérification à la compilation, aucune vérification à lexécution) : reinterpret_cast ( choux ) Les casts "à la C" sont toujours accepté en C++ : (Carotte)choux Mais, les casts étant une source notable derreurs, il est bon de pouvoir les énumérer avec un simple grep !

static_cast Accepte uniquement de convertir un type en un type dérivé à la compilation ; aucune vérification à lexécution : static_cast ( choux ) Refuse notamment de convertir des pointeurs en entiers longs : static_cast ( apointer ) Utiliser reinterpret_cast, pas un cast "à la C" !

dynamic_cast Accepte uniquement de convertir un type en un type dérivé à la compilation avec vérification à lexécution, en utilisant le RTTI : dynamic_cast ( choux ) En cas derreur (le type dynamique de lexpression nest pas un type dérivé du type cible) : Les conversions de pointeurs retournent 0/NULL Les conversions de références lancent une exception std::bad_cast dynamic_cast est très similaire aux casts (de références) en Java

Upcasts et héritage multiple Lupcast en cas dhéritage multiple est ambigu : const D * const d= new D(); static|dynamic_cast ( d ) // ambigu ! Il faut dabord caster en B ou C, puis en A.

Downcasts et héritage virtuel Le downcast en cas dhéritage virtuel est ambigu : const A * const a= new E(); static|dynamic_cast ( a ) // ambigu ! Il faut dabord caster en E, puis en C ou D, puis en B.

const_cast Supprime, à la compilation, le caractère const ou volatile des expressions : (const_cast ( areference )).NonConstMethod(); Tout aussi alarmant concernant le design que dutiliser mutable …

Des casts contrôlés en mode debug Les casts sont malheureusement souvent nécessaires alors quils sont sources derreurs ! static_cast est dangereux, mais dynamic_cast est plus lent… Idée : utiliser une macro qui utilise dynamic_cast en mode debug et static_cast en mode release : #ifndef CHECKCASTS_ENABLED # define CASTREFERENCE( TargetType, SourceType, expr ) \ (static_cast ( expr )) #else # define CASTREFERENCE( TargetType, SourceType, expr ) \ (DynamicCastReference ( expr, \ __FILE__, \ __LINE__, \ #expr )) #endif

Des casts contrôlés en mode debug template TargetType& DynamicCastReference( SourceType& expr, const char * const strFilename, const int iLineNumber, const char * const strExpr ) { if (&expr == NULL) return (TargetType &)expr; else { TargetType * const result= dynamic_cast ( &expr ); if (result == NULL) ReferenceCastFailed( strExpr, strFilename, iLineNumber, typeid( expr ).name(), typeid( TargetType ).name() ); return *result; }

Des casts contrôlés en mode debug Inconvénient : il faut écrire le type source de lexpression. Mais, en cas derreur, lexécution du programme se termine immédiatement (on nattend pas que lerreur se propage), avec un yoli message derreur indiquant : le fichier et la ligne contenant lerreur ; lexpression fautive ; son type dynamique ; le type en lequel on a tenté de la convertir. Et tout cela aisément débranchable en mode release. Cela ne vaut-il pas la peine de taper quelques caractères supplémentaires ?

Lopérateur instanceof en C++ Rappel : type_info::before napporte aucune indication hiérarchique ! tenter de caster avec dynamic_cast, en utilisant des pointeurs (donc en prenant ladresse des références le cas échéant) et en testant que le résultat de dynamic_cast nest pas 0/NULL, sauf si le pointeur létait auparavant… a instanceof A ((a == 0) || (dynamic_cast ( a ) != 0))

Utilisez au maximum le typage statique ! Une des forces de C++ pour la correction des programmes est son très fort typage statique. Ne vous adonnez pas aux " switch es de type" : utilisez plutôt le polymorphisme !