Conversion de types en C : Maîtriser les conversions implicites et explicites avec exemples de code

Qu'est-ce que le transtypage (typecasting) en C ?

En C, le transtypage — ou conversion de données — est le processus de conversion d'une valeur d'un type de données à un autre. C'est un concept fondamental que tout programmeur C devrait maîtriser.

Conversion de type implicite

La conversion de type implicite (ou automatique) se produit quand le compilateur convertit silencieusement un type de données en un autre sans intervention du développeur. Cela se produit seulement quand la conversion préserve la signification de la valeur et que le type cible peut représenter la valeur source.

1. La conversion implicite est effectuée automatiquement pendant l'affectation, les appels de fonction et les opérations arithmétiques.
2. Quand deux opérandes ont des types différents, l'opérande avec le rang inférieur est promu au type avec le rang supérieur.

Considérez cet exemple :

#include<stdio.h>
int main() {
    short a = 10; // short int
    int b; // int
    b = a; // cast implicite
    printf("%d\n", a);
    printf("%d\n", b);
    return 0;
}

Sortie :

10
10

Le compilateur promeut la valeur short en int automatiquement, assurant qu'aucune information n'est perdue.

Promotion de caractère en entier

Quand un char participe à une expression arithmétique, le compilateur le promeut en int en utilisant son code ASCII :

#include <stdio.h>
int main() {
    int number = 1;
    char character = 'k'; /* ASCII 107 */
    int sum = number + character;
    printf("Value of sum : %d\n", sum);
    return 0;
}

Sortie :

Value of sum : 108

Hiérarchie de conversion arithmétique

Le standard C définit une hiérarchie qui détermine le type cible pour l'arithmétique à types mixtes. Si les opérandes diffèrent après toute promotion de caractère, le compilateur les convertit au type au sommet du graphique suivant :

Exemple :

#include <stdio.h>
int main() {
    int num = 13;
    char c = 'k'; /* 107 */
    float sum = num + c;
    printf("sum = %f\n", sum);
    return 0;
}

Sortie :

sum = 120.000000

Ici, c est d'abord promu en int, puis les deux opérandes deviennent float avant l'addition.

Points clés sur les conversions implicites

• Elles sont aussi appelées conversions standard ; aucun opérateur de cast n'est requis.
• Promouvoir un type plus petit vers un plus grand est connu comme promotion de type.
• Seuls les types compatibles peuvent être convertis implicitement ; sinon le compilateur émet un avertissement ou erreur.
• Les conversions incompatibles qui perdent de l'information (ex. double vers float) doivent être évitées ou explicitement castées.

Conversion de type explicite

Le cast explicite force une conversion que le compilateur n'effectuerait pas automatiquement. C'est essentiel quand vous avez besoin de la représentation exacte, comme tronquer une partie fractionnaire ou convertir entre types non liés.

La syntaxe est simple :

(nom-type) expression

Exemple de cast explicite dans une division qui tronquerait sinon le résultat :

#include <stdio.h>
int main() {
    int var1 = 10, var2 = 3;
    int result = var1 / var2; // 3, fraction perdue
    int result2 = (int)((float)var1 / var2); // 3.333… cast en int -> 3
    printf("result = %d\n", result);
    printf("result2 = %d\n", result2);
    return 0;
}

Les casts explicites sont aussi utiles pour convertir entre types non liés, comme montré ci-dessous :

#include <stdio.h>
int main() {
    float a = 1.2;
    int b = (int)a + 1; // cast float vers int
    printf("Value of a is %f\n", a);
    printf("Value of b is %d\n", b);
    return 0;
}

Sortie :

Value of a is 1.200000
Value of b is 2

Résumé

• Le transtypage convertit une valeur d'un type à un autre.
• Les conversions implicites sont automatiques et sûres quand les types sont compatibles.
• Les conversions explicites utilisent un opérateur de cast pour forcer un changement.
• Revoyez toujours les conversions pour une perte potentielle de données.

Meilleures pratiques

• Quand possible, convertissez int en float avant d'effectuer une division pour préserver la précision.
• Préférez float à double seulement quand les contraintes de mémoire l'imposent.
• Utilisez int pour l'arithmétique entière ; réservez char pour les données textuelles.