C Academy · Leçon

Conversions d’entiers et de flottants

Problèmes de précision

Conversions d’entiers et de flottants est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Deux mondes numériques

En C, il existe des entiers (exacts, sans fraction) et des nombres à virgule flottante (approximatifs, avec une fraction). Les convertir modifie la manière dont une valeur est stockée.

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

Élargir int en double

La plupart des valeurs int sont représentables exactement dans un double ; l’élargissement est donc sûr.

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

Réduire double en int

Passer de double à int tronque vers zéro et peut entraîner une perte d’informations.

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

Troncature des nombres négatifs

La troncature vers zéro signifie que -2.9 devient -2, et non -3.

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

Précision de float et double

float contient environ 7 chiffres significatifs, contre environ 15 pour double. Convertir un double en float fait perdre de la précision.

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

Grand int vers float

Un int très grand peut ne pas être représentable exactement en float, ce qui produit un résultat arrondi.

#include <stdio.h>
int main(void) {
    int big = 16777217;
    float f = (float)big;
    printf("%.1f\n", f);
    return 0;
}

Arrondir ou tronquer

Une conversion tronque. Pour arrondir, ajoutez d’abord 0.5 (pour les valeurs positives) ou utilisez des fonctions de bibliothèque.

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

Calcul d’une moyenne

Pour calculer la moyenne d’entiers, utilisez une division flottante afin de conserver la fraction.

#include <stdio.h>
int main(void) {
    int sum = 7, count = 2;
    double avg = (double)sum / count;
    printf("avg = %.2f\n", avg);
    return 0;
}

Piège de l’égalité des nombres flottants

Les nombres flottants étant approximatifs, les comparer avec == est risqué. Comparez-les dans une petite tolérance.

#include <stdio.h>
#include <math.h>
int main(void) {
    double a = 0.1 + 0.2;
    if (fabs(a - 0.3) < 1e-9)
        printf("close enough\n");
    return 0;
}

Mélange dans les conditions

Comparer un int à un double promeut l’int en double ; la comparaison s’effectue donc en virgule flottante.

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

Choisir le bon type

Utilisez des entiers pour les décomptes et les indices, et la virgule flottante pour les mesures et les rapports.

#include <stdio.h>
int main(void) {
    int items = 4;
    double pricePer = 2.5;
    printf("total = %.2f\n", items * pricePer);
    return 0;
}

Vérification rapide

Testez votre compréhension des conversions entre entiers et nombres flottants.

Récapitulatif : conversions entre entiers et nombres flottants

Vous avez appris comment les nombres changent selon les types.

Le passage de int à double élargit généralement la valeur sans risque
Le passage de double à int tronque vers zéro
float conserve moins de chiffres que double
Arrondissez en ajoutant 0.5 ou en utilisant des fonctions de bibliothèque
Évitez == avec les nombres flottants ; utilisez une tolérance

Questions Fréquemment Posées

La leçon « Conversions d’entiers et de flottants » est-elle gratuite ?

Oui — le texte complet de « Conversions d’entiers et de flottants » 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 « Conversions d’entiers et de flottants » ?

Problèmes de précision 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 3 sur 4.

Combien de temps prend la leçon « Conversions d’entiers et de flottants » ?

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