static_cast vs dynamic_cast vs cast de style C : comment ne pas casser le code

Introduction : pourquoi la conversion de types en C++ est un champ de mines

Avez-vous déjà écrit quelque chose comme (int)someFloat en espérant que tout irait bien ? Ou peut-être avez-vous rencontré une situation où le programme compile, mais plante à l'exécution avec une erreur mystérieuse ? Bienvenue dans le monde de la conversion de types en C++ — un endroit où même les développeurs expérimentés perdent des heures à déboguer.

La question "Regular cast vs. static_cast vs. dynamic_cast" sur Stack Overflow a recueilli des dizaines de milliers de vues. Et ce n'est pas un hasard. Chaque type de conversion est un outil avec son propre objectif, et utiliser le mauvais outil peut entraîner un comportement indéfini, des fuites mémoire ou simplement un code qui ne fonctionne pas.

Dans cet article, nous allons analyser les trois principales méthodes de conversion de types en C++, montrer les erreurs les plus fréquentes et donner des recommandations claires pour les éviter. À la fin, vous saurez exactement quel cast utiliser dans chaque situation spécifique.

1. Regular cast (cast de style C) — un héritage du passé

Le bon vieux cast de style C est la méthode de conversion la plus simple, mais aussi la plus dangereuse. Il se présente ainsi : (NouveauType)expression. En C++, il est considéré comme "régulier", mais son comportement peut grandement surprendre.

Comment ça fonctionne ?

Le compilateur C++ tente d'interpréter le cast de style C comme une séquence de static_cast, const_cast et reinterpret_cast. Il choisit la première combinaison appropriée. Le problème est que vous ne savez jamais quel cast sera effectué au final.

Exemple d'erreur : modification accidentelle de la constance

const int valeur = 42;\nint* ptr = (int*)&valeur;  // Le cast de style C supprime const\n*ptr = 100;               // Comportement indéfini !\ncout << valeur;           // Peut afficher 42, 100 ou n'importe quoi

Ce code compile sans erreur, mais conduit à un comportement indéfini. const_cast serait ici plus honnête — il montrerait au moins votre intention.

Quand le cast de style C est-il encore acceptable ?

\n
• Jamais en C++ moderne (C++11 et versions ultérieures).
\n
• Uniquement pour des conversions numériques très simples où le risque est minime (par exemple, (float)valeurInt), mais même dans ce cas, il est préférable d'utiliser static_cast.
\n

Conclusion : oubliez le cast de style C. Il rend le code illisible et non sécurisé. Les compilateurs modernes peuvent même émettre des avertissements sur de telles constructions.

2. static_cast — le soldat universel

static_cast est le type de conversion le plus couramment utilisé en C++. Il effectue une vérification à la compilation et convient à la plupart des situations où la conversion de types est logiquement correcte.

Quand utiliser static_cast ?

\n
• Conversion de types numériques : double → int, int → float.
\n
• Upcast (conversion d'un pointeur sur une classe dérivée en pointeur sur la classe de base).
\n
• Conversion explicite de void* vers un type spécifique.
\n
• Appel de constructeurs avec un seul argument (mais il est préférable d'utiliser explicit).
\n

Exemple : upcast correct

class Base { public: virtual void parler() { cout << "Base"; } };\nclass Derivee : public Base { public: void parler() override { cout << "Derivee"; } };\n\nDerivee d;\nBase* b = static_cast<Base*>(&d);  // upcast — sûr\nb->parler();  // Affichera "Derivee" grâce à la fonction virtuelle

Erreur n°1 : Slicing lors du passage par valeur

L'une des erreurs les plus sournoises est le slicing (troncature d'objet). Elle se produit lorsque vous convertissez un objet d'une classe dérivée en classe de base par valeur, et non par référence ou pointeur