Le langage C++ propose principalement **trois approches** distinctes pour la vérification des types :

1. La reconnaissance de type à l'exécution avec typeid
2. La déduction de type à la compilation avec decltype
3. Le casting sécurisé pour les hiérarchies d'héritage avec dynamic_cast

Un. Reconnaissance de Type à l'Exécution avec typeid

1. En-tête requis

#include <typeinfo>

2. Utilisation de base

La syntaxe de base est :

typeid(variable/expression/type)

Cette expression retourne un objet de type std::type_info et permet d'obtenir le type réel à l'exécution ainsi que de vérifier l'égalité des types.

3. Exemple fondamental

#include <iostream>
#include <typeinfo>
using namespace std;

int main()
{
    int valeur = 10;
    double reel = 3.14;

    // Vérification du type
    if (typeid(valeur) == typeid(int))
    {
        cout << "valeur est de type int" << endl;
    }

    // Affichage du nom du type
    cout << typeid(reel).name() << endl;
    return 0;
}

4. Caractéristiques importantse

• Types primitifs : détection précise
• Classes polymorphiques (avec fonctions virtuelles) : identification du vrai sous-type réel de l'objet
• Classes non polymorphiques : reconnaissance uniquement du type statiquement déclaré, sans identification des sous-types réels

Deux. Application aux Polymorphismes : Détection du Type Réel

#include <iostream>
#include <typeinfo>
using namespace std;

class ClasseMere {
public:
    virtual void fonction() {} // Nécessaire pour activer RTTI
};

class ClasseFille : public ClasseMere {};

int main()
{
    ClasseMere* pointeur = new ClasseFille;

    if (typeid(*pointeur) == typeid(ClasseFille))
    {
        cout << "pointeur pointe réellement vers un objet de ClasseFille" << endl;
    }

    return 0;
}

La présence de fonctions virtuelles combinée à typeid(*pointeur) permet d'obtenir le vrai type réel de l'objet.

Trois. Casting Sécurisé avec dynamic_cast (Méthode la Plus Courante)

Cet opérateur spécialisé sert à :

Vérifier si un pointeur/référence de classe de base appartient à un sous-type spécifique

En cas d'échec de conversion :

• Pour les pointeurs : retourne nullptr
• Pour les références : lève une exception

ClasseMere* p = new ClasseFille;

// Tentative de conversion vers le sous-type
ClasseFille* f = dynamic_cast<ClasseFille*>(p);
if (f != nullptr)
{
    cout << "Conversion réussie, les types correspondent" << endl;
}

En pratique, dynamic_cast est préféré pour la vérification de types dans les hiérarchies polymorphiques en raison de sa sécurité et de sa stabilité.

Quatre. Déduction de Type à la Compilation avec decltype

Si typeid permet d'inspecter les types à l'exécution, decltype effectue une déduction de type à la compilation.

int nombre = 10;
// Déduction du type de nombre et création d'une nouvelle variable
decltype(nombre) autre = 20; 

Applications principales : programmation générique, déduction automatique de types complexes, sans intervention à l'exécution.

Cinq. Pièges Courants avec typeid

1. Absence de fonctions virtuelles
   Lorsqu'un pointeur de classe de base pointe vers un sous-type, typeid ne reconnaîtra que le type de base, rendant la vérification inefficace.
2. typeid(pointeur) et typeid(*pointeur) sont différents

typeid(p)      // Vérifie le type du pointeur (ClasseMere*)
typeid(*p)     // Vérifie le type réel de l'objet pointé

3. Le résultat de type_info::name() est spécifique au compilateur et peut varier, ne l'utiilsez pas pour des comparaisons de chaînes.

Six. Synthèse du Choix des Méthodes

1. Vérification de types primitifs simples → typeid
2. Vérification de types dans les hiérarchies d'héritage, conversion sécurisée → dynamic_cast (option privilégiée)
3. Déduction automatique de types à la compilation → decltype
4. Besoin d'identifier le sous-type réel à l'exécution → classe de base avec fonctions virtuelles + typeid(*objet)