Chapitre 5

5.1 Introduction

Les conversions (cast) peuvent être faites par des mots-clés dédiés

1. Casting statique (à la compilation)

static_cast<> entre types de la même famille*

reinterpret_cast<> entre types de familles différentes

const_cast<> ajouter/ supprimer const

2. Casting dynamique (à l'exécution - runtime)

dynamic_cast<> entre types de la même famille*

⚠️ ATTENTION : les casts «à la C» sont possibles mais non recommandés

5.2 static_cast

Syntaxe

var = static_cast<typeDest>(var)

Exemple

char c = static_cast<char>(i);

5.2 static_cast

static_cast sert aux conversions qui auraient pu être effectuées de manière implicite

            int i = 100;
            auto c = static_cast<char>(i); // int -> char
              
            auto f = 100.0f;
            i = static_cast<int>(f); // float -> int
              
            class Base{};
            class Deri : public Base{};
            auto d = new Deri;
            auto b = static_cast<Base*>(d); // Deri* -> Base*
          

✅ évite les warning des conversions implicites

5.2 static_cast

static_cast sert aux conversions qui auraient pu être effectuées de manière implicite

            char c = 10;       // 1 byte
            int *p = (int*)&c; // 4 bytes
            
            *p = 5; // run-time error: stack corruption
            
            int *q = static_cast<int*>(&c); // compile-time error
            

✅ détecte les erreurs à la compilation

5.3 reinterpret_cast

static_cast ne fonctionne pas avec des pointeurs de type différents

            
            auto f = 99.0f;
            auto pf = &f;
            auto d = 99.0;
            auto pd = &d;
            pd = static_cast<double*> (pf); // ⛔ error
            pd = reinterpret_cast<double*>(pf); // ✅ ok
          

✅ reinterpret_cast sert aux conversions* entre types de familles différentes (p.ex. entier vers pointeur)

*aucune donnée n'est physiquement modifiée, ce n'est qu'une indication pour le compilateur

5.3 reinterpret_cast

            
            int i = 99;
            auto ptr = reinterpret_cast<char*>(i); // int -> char*
            auto ref = reinterpret_cast<char&>(i); // int -> char&
            auto pf = reinterpret_cast<float*>(pd); // double* -> float*
          

⛔ reinterpret_cast est peu portable. Son usage est peu recommandé !

Utile pour scanner de la mémoire (scanner un range de int avec reinterpret_cast<char*>(adr) pour voir byte par byte le codage, faire un désassembleur, etc.)

5.4 const_cast

const_cast permet d'ajouter ou supprimer les qualificatifs const, volatile

            class A{};
            const A *cptr;
            auto ptr = const_cast<A*>(cptr); // const A* -> A*
            
            A a;
            const A &cref = a;
            auto ref = const_cast<A&>(cref); // const A& -> A&
            

Opérateur peu utile, car :

- la conversion non-const ⇒ const est implicite

- la conversion const ⇒ non-const relève souvent d'une erreur de conception

- le qualificatif volatile est rarement utilisé

5.4 const_cast

⛔ const_cast est dangereux et peut entraîner des comportements indéfinis

Il est utilisé pour supprimer la constance des références et des pointeurs qui se réfèrent à quelque chose qui, à la base, n'est pas const

Les seules possibilités de conversion sont

X ⇔ const X

X ⇔ volatile X

volatile X ⇔ const X

volatile : sert lors de la programmation système. Elle indique qu'une variable peut être modifiée en arrière-plan par un autre programme (par exemple par une interruption, par un thread, par un autre processus, par le système d'exploitation ou par un autre processeur dans une machine parallèle)

5.5 dynamic_cast

dynamic_cast est utilisé pour les conversions entre classes polymorphiques

⇒ elle doit comporter au moins une fonction membre virtuelle

⇒ être manipulée au moyen d'un pointeur ou d'une référence

5.5 dynamic_cast

Ce type de cast est dynamique (effectué à l'exécution), et est susceptible d'échouer :

⇒ renvoie nullptr pour les conversions de pointeurs

⇒ lève une exception std::bad_cast pour les conversions de référence

5.5 dynamic_cast - Exemples

            Product *products[100];
            
            for (auto i = 0; i < 100; ++i)
            {
              auto ptrLiquor = dynamic_cast<Liquor*>(products[i]);
                
              if (ptrLiquor != nullptr)
              {
                std::println("{}", ptrLiquor->degree());
              }              
              else
              {
                std::println("{}", products[i]->name());
              }
            }
          

5.5 dynamic_cast - Commentaires

dynamic_cast identifie à l'exécution le type réel de l'expression reçue par RTTI (RunTime Type Information)

dynamic_cast peut facilement être utilisé à tort, signe d'une mauvaise conception :

- La fonction que l'on écrit ne travaille en fait pas sur la classe de base, mais seulement sur certaines classes dérivées bien identifiées

- Polymorphisme dynamique pas exploité (fonctions virtuelles)

- Polymorphisme statique pas exploité (utilisation de templates, surcharges)

- Hiérarchie de classes mal structurée

5.6 RTTI

RTTI : RunTime Type Information

Permet de déterminer le type d'une variable à l'exécution (runtime)

Le mécanisme RTTI contient :

- Le mot-clé de conversion dynamic_cast

- L'opérateur typeid de la classe type_info

⚠️ Note : certains compilateurs embarqués désactivent le RTTI par défaut pour économiser la mémoire flash.

5.6 Opérateur typeid

typeid retourne un objet de type type_info qui contient des informations sur le type de l'expression

⇒ utilisé pour vérifier le type d'un objet à l'exécution

            typeid(int).name() // ⇒ i
            typeid(float).name() // ⇒ f
            typeid(2+2.00).name() // ⇒ d
            typeid(ptri).name() // ⇒ Pi
            typeid(ptrf).name() // ⇒ Pf
            typeid(refd).name() // ⇒ d
            AAA a;
            typeid(a).name() // ⇒ Z4mainE3AAA
          

5.6 Opérateur typeid - Exemple

          class Animal { public: virtual ~Animal(){}};
          class Mammal : public Animal {};
          class Dog : public Mammal {};
          class Poodle : public Dog {};
          
          int main()
          {
            Animal *ptr = new Poodle;
            typeid(ptr).name(); // ⇒ P6Animal
            typeid(*ptr).name(); // ⇒ 7Poodle
            typeid(*ptr) == typeid(Dog); // ⇒ false
            typeid(*ptr) == typeid(Poodle); // ⇒ true

            return 0;
          }
        

5.6 Opérateur typeid vs dynamic_cast

typeid → vérifie le type exact d'un objet à l'exécution

dynamic_cast → vérifie si un objet est compatible avec un type cible ("IS-A")

typeid est plus rapide

dynamic_cast est plus sûr

          if (typeid(*ptr) == typeid(Dog)) {...}
          
          if (auto c = dynamic_cast<Dog*>(ptr)) {...}