Conversion de types en C++ : static_cast, conversions implicites et casts

Ce qu'est la conversion de types

Convertir des types signifie transformer une valeur d'un type vers un autre : transformer un double en int, un char en son code numérique, ou un pointeur de classe de base en pointeur de classe dérivée. Le C++ effectue certaines de ces conversions pour toi automatiquement, mais celles qu'il fait en silence sont précisément là où se cachent les bugs.

Il y a deux variantes : les conversions implicites qui se produisent toutes seules, et les casts explicites que tu écris toi-même. Tu as déjà rencontré un symptôme de cela dans opérateurs : la division entière. Le cast est la façon d'en reprendre le contrôle.

Conversions implicites

Quand tu mélanges des types numériques dans une expression, le C++ promeut le type « le plus petit » vers « le plus grand » pour que les deux côtés correspondent. Cela fait en général ce que tu veux.

#include <iostream>
using namespace std;

int main() {
    int apples = 3;
    double price = 1.5;

    double total = apples * price;   // int -> double automatiquement
    cout << total << endl;           // 4.5

    char c = 'A';
    int code = c;                    // char -> int (le code ASCII)
    cout << code << endl;            // 65
    return 0;
}

Les ennuis commencent quand la conversion va dans l'autre sens : d'un type plus large vers un type plus étroit. C'est une conversion par restriction, et elle peut perdre des données en silence.

#include <iostream>
using namespace std;

int main() {
    double pi = 3.99;
    int rounded = pi;        // restriction : la fraction est supprimée, PAS arrondie
    cout << rounded << endl; // 3

    int big = 300;
    char small = big;        // 300 ne tient pas dans un char
    cout << static_cast<int>(small) << endl; // 44 (enveloppé !)
    return 0;
}

De float vers int, on tronque vers zéro : il n'y a pas d'arrondi, donc 3.99 devient 3. Et faire entrer 300 dans un char provoque un débordement. Beaucoup de compilateurs avertissent ici ; certains non. Quand tu veux vraiment restreindre, dis-le explicitement avec un cast pour que le prochain lecteur sache que c'était intentionnel.

Corriger le piège de la division entière

La raison la plus fréquente de faire un cast est la division. Quand les deux opérandes sont des entiers, / effectue une division entière et jette le reste.

#include <iostream>
using namespace std;

int main() {
    int got = 7;
    int total = 10;

    double wrong = got / total;                       // 0  (division entière d'abord !)
    double right = static_cast<double>(got) / total;  // 0.7

    cout << wrong << endl;
    cout << right << endl;
    return 0;
}

La correction consiste à appliquer static_cast<double> à un opérande avant la division. Une erreur fréquente est static_cast<double>(got / total) : c'est trop tard, car got / total vaut déjà 0 au moment où le cast s'exécute, donc tu obtiens 0.0. Convertis un opérande, pas le résultat.

static_cast : ton cast par défaut

Le C++ te donne quatre casts nommés. Celui que tu utiliseras 95 % du temps est static_cast<T>(value), qui réalise des conversions bien définies entre types apparentés : conversions numériques, d'enum vers int, de void* de retour vers un pointeur typé, et la montée/descente dans une hiérarchie de classes quand tu connais déjà le type.

#include <iostream>
using namespace std;

int main() {
    double balance = 19.95;
    int dollars = static_cast<int>(balance);   // 19, fraction supprimée

    int letter = 100;
    char ch = static_cast<char>(letter);       // 'd'

    cout << dollars << endl;   // 19
    cout << ch << endl;        // d
    return 0;
}

Préfère static_cast à l'ancien cast à la C (int)balance. Un cast à la C essaiera n'importe quelle conversion pour que le code compile, y compris les dangereuses ci-dessous, si bien qu'il peut retirer le const en silence ou réinterpréter des octets bruts. static_cast n'autorise que les conversions que le compilateur peut réellement justifier, et le verbeux static_cast<...> est trivial à retrouver lors d'une revue de code.

// À éviter - cast à la C, aucun filet de sécurité :
int dollars = (int) balance;

// À préférer - explicite, vérifié, facile à retrouver :
int dollars = static_cast<int>(balance);

Les trois autres casts (à utiliser avec parcimonie)

Les casts restants existent pour des tâches précises et étroites. N'y recours que lorsque static_cast ne peut vraiment pas le faire.

const_cast retire (ou ajoute) const. Son seul usage légitime est d'appeler une API à la C qui a oublié de marquer un paramètre const. Modifier, via un const_cast, un objet qui a été initialement déclaré const est un comportement indéfini.

void legacyApi(char* msg);   // ancienne API, ne prend pas de const

const char* text = "hello";
legacyApi(const_cast<char*>(text));   // correct uniquement si legacyApi n'y écrit pas

reinterpret_cast réinterprète le motif de bits brut, par exemple un pointeur comme une adresse entière. Il n'effectue aucune conversion et est extrêmement dangereux ; c'est presque toujours le signe que tu devrais repenser la conception.

dynamic_cast convertit en toute sécurité un pointeur ou une référence de classe de base vers un type dérivé à l'exécution, en utilisant le type réel de l'objet. Il exige une base polymorphe (une classe avec au moins une fonction virtual) et renvoie nullptr si le cast ne s'applique pas.

#include <iostream>
using namespace std;

struct Animal { virtual ~Animal() = default; };
struct Dog : Animal { void bark() { cout << "Woof!" << endl; } };

int main() {
    Animal* a = new Dog();

    if (Dog* d = dynamic_cast<Dog*>(a)) {  // réussit : a est bien un Dog
        d->bark();
    } else {
        cout << "not a Dog" << endl;
    }

    delete a;
    return 0;
}

Si a avait pointé vers un autre Animal, dynamic_cast<Dog*> renverrait nullptr et la branche else s'exécuterait, ce qui est exactement la raison pour laquelle il est plus sûr que d'utiliser aveuglément static_cast pour descendre dans une hiérarchie.

Erreurs courantes à éviter

• Convertir le résultat au lieu d'un opérande. static_cast<double>(a / b) supprime d'abord ta fraction. Convertis a ou b.
• Supposer que de float vers int on arrondit. On tronque : static_cast<int>(2.99) vaut 2. Pour arrondir, utilise std::round, std::lround, etc.
• Recourir à un cast à la C. Il masque quelle conversion a lieu. Utilise static_cast et tu obtiendras une erreur de compilation quand la conversion est dangereuse, plutôt qu'une surprise silencieuse.
• Restreindre vers un type trop petit. Convertir 300 en char ou un énorme long en int provoque un enveloppement ou un débordement. Choisis un type cible assez large pour la plage.

Suivant : If-Else

Maintenant que tu peux convertir et comparer des valeurs proprement, l'étape suivante est de prendre des décisions avec elles. L'instruction if-else exécute du code différent selon qu'une condition est true : le fondement de tout programme à branchements.