C Academy · Leçon

Pièges des conversions

Dépassement et troncature

Pièges des conversions est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Les conversions peuvent être piégeuses

Les conversions silencieuses sont pratiques, mais peuvent provoquer des dépassements de capacité, des troncatures et des surprises liées au signe. Cette leçon présente ces pièges.

#include <stdio.h>
int main(void) {
    printf("Beware silent conversions\n");
    return 0;
}

Dépassement de capacité des entiers

Affecter une valeur trop grande pour le type entier cible provoque un retour cyclique ou une perte de données.

#include <stdio.h>
#include <limits.h>
int main(void) {
    int max = INT_MAX;
    printf("INT_MAX = %d\n", max);
    return 0;
}

Troncature lors d’une réduction de type

Placer une grande valeur dans un type plus petit ne conserve que les bits de poids faible, ce qui corrompt silencieusement le nombre.

#include <stdio.h>
int main(void) {
    int big = 300;
    unsigned char small = (unsigned char)big;
    printf("small = %d\n", small);
    return 0;
}

Mélange de signés et non signés

Mélanger des valeurs signées et non signées convertit la valeur signée en valeur non signée, transformant les nombres négatifs en énormes nombres positifs.

#include <stdio.h>
int main(void) {
    int a = -1;
    unsigned int b = 1;
    if (a > b)
        printf("surprise: -1 > 1 as unsigned\n");
    return 0;
}

Piège du compteur de boucle

Un compteur de boucle unsigned qui descend sous zéro revient cycliquement à une valeur énorme et provoque une boucle infinie. Utilisez des compteurs signés pour compter à rebours.

#include <stdio.h>
int main(void) {
    for (int i = 3; i >= 0; i--)
        printf("%d ", i);
    printf("\n");
    return 0;
}

Perte lors du passage de float à int

Convertir un float en int fait perdre la fraction. Si la valeur dépasse l’intervalle de int, le résultat n’est pas défini.

#include <stdio.h>
int main(void) {
    double d = 3.99;
    int n = (int)d;
    printf("n = %d\n", n);
    return 0;
}

Perte de précision de double à float

Stocker un double très précis dans un float supprime des chiffres, ce qui peut s’accumuler lors de calculs longs.

#include <stdio.h>
int main(void) {
    double d = 1.123456789012345;
    float f = (float)d;
    printf("%.7f\n", f);
    return 0;
}

Surprises liées au signe de char

Le fait que char soit signé ou non dépend de l’implémentation. Utilisez unsigned char pour les valeurs d’octet afin d’éviter les résultats négatifs.

#include <stdio.h>
int main(void) {
    unsigned char b = 200;
    printf("b = %d\n", b);
    return 0;
}

Diviser puis convertir

Effectuer une division entière puis convertir le résultat ne permet pas de récupérer la fraction perdue. Convertissez avant de diviser.

#include <stdio.h>
int main(void) {
    int a = 7, b = 2;
    double wrong = (double)(a / b);
    double right = (double)a / b;
    printf("%.1f vs %.1f\n", wrong, right);
    return 0;
}

Comparer les tailles

Utilisez les constantes de limits.h pour connaître l’intervalle qu’un type peut contenir avant de supposer qu’une valeur y tient.

#include <stdio.h>
#include <limits.h>
int main(void) {
    printf("char range: %d to %d\n", CHAR_MIN, CHAR_MAX);
    return 0;
}

Conversions défensives

Vérifiez les intervalles avant de réduire un type, préférez des types plus larges en cas de doute et rendez les conversions explicites afin que l’intention soit claire.

#include <stdio.h>
int main(void) {
    long value = 200;
    if (value >= 0 && value <= 255)
        printf("fits in a byte: %ld\n", value);
    return 0;
}

Vérification rapide

Testez votre compréhension des pièges des conversions.

Récapitulatif : pièges des conversions

Vous avez appris les dangers des conversions silencieuses.

Une réduction de type peut provoquer un dépassement de capacité ou une troncature
Le mélange de types signés et non signés inverse les comparaisons
Les compteurs non signés reviennent cycliquement sous zéro
Convertissez avant de diviser pour conserver les fractions
Vérifiez les intervalles et rendez les conversions explicites

Questions Fréquemment Posées

La leçon « Pièges des conversions » est-elle gratuite ?

Oui — le texte complet de « Pièges des conversions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pièges des conversions » ?

Dépassement et troncature Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Pièges des conversions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy