C Academy · Leçon

Pièges courants des entrées-sorties

Problèmes de tampon et de nouvelle ligne

Leçon 4 sur 413 étapes

Pièges courants des entrées-sorties 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.

Bugs courants des entrées-sorties

Les entrées et sorties en C présentent quelques pièges classiques. Les connaître vous fait gagner des heures de débogage.

#include <stdio.h>
int main(void) {
    printf("Let us study I/O pitfalls\n");
    return 0;
}

Le saut de ligne restant

Après scanf("%d", ...), la touche Entrée laisse un \n dans le tampon. Un %c ultérieur lit ce saut de ligne au lieu d’une véritable entrée.

#include <stdio.h>
int main(void) {
    char c = 'A';
    printf("Use a space before %%c to skip the leftover newline\n");
    printf("c = %c\n", c);
    return 0;
}

Correction avec une espace

Écrire scanf(" %c", &c) avec une espace initiale indique à scanf d’ignorer d’abord les espaces blancs.

#include <stdio.h>
int main(void) {
    char c = 'Z';
    printf("scanf(\" %%c\", &c) skips whitespace\n");
    printf("c = %c\n", c);
    return 0;
}

Oublier l’esperluette

Passer une variable à scanf sans & entraîne un stockage à une adresse incorrecte et provoque probablement un plantage.

#include <stdio.h>
int main(void) {
    int n = 9;
    printf("Always pass &n, not n, to scanf for an int\n");
    printf("n = %d\n", n);
    return 0;
}

Spécificateurs incompatibles

Lire un double avec %f au lieu de %lf dans scanf corrompt la valeur. La sortie utilise %f dans les deux cas, mais l’entrée diffère.

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

Mise en tampon des sorties

La sortie peut être mise en tampon et ne pas apparaître immédiatement. Terminer par \n ou appeler fflush(stdout) vide le tampon.

#include <stdio.h>
int main(void) {
    printf("Flushed by newline\n");
    fflush(stdout);
    return 0;
}

gets est dangereux

L’ancienne fonction gets ne vérifiait pas les limites et a été supprimée du C moderne. Utilisez plutôt fgets.

#include <stdio.h>
int main(void) {
    char buf[10];
    /* fgets(buf, sizeof buf, stdin); */
    buf[0] = 'H'; buf[1] = 'i'; buf[2] = 0;
    printf("buf = %s\n", buf);
    return 0;
}

Débordement de tampon avec %s

Un simple %s dans scanf peut écrire au-delà d’un petit tableau. Limitez-le avec une largeur telle que %19s.

#include <stdio.h>
int main(void) {
    char name[20];
    printf("Use %%19s to leave room for the null terminator\n");
    name[0] = 0;
    printf("name length cap protects buffer\n");
    return 0;
}

fgets conserve le saut de ligne

fgets stocke le saut de ligne final. Vous devez souvent le supprimer.

#include <stdio.h>
#include <string.h>
int main(void) {
    char line[] = "hello\n";
    line[strcspn(line, "\n")] = 0;
    printf("[%s]\n", line);
    return 0;
}

Ignorer les valeurs de retour

Ne pas vérifier la valeur de retour de scanf permet à une entrée incorrecte de passer silencieusement. Vérifiez-la toujours.

#include <stdio.h>
int main(void) {
    int n = 3;
    int items = 1;
    if (items != 1)
        printf("bad input\n");
    else
        printf("ok: %d\n", n);
    return 0;
}

Assemblage sécurisé

Une méthode robuste consiste à lire avec fgets, à analyser avec sscanf, puis à vérifier le résultat.

#include <stdio.h>
int main(void) {
    char line[] = "123";
    int n;
    if (sscanf(line, "%d", &n) == 1)
        printf("parsed %d\n", n);
    return 0;
}

Vérification rapide

Testez votre compréhension des pièges des entrées-sorties.

Récapitulatif : pièges courants des entrées-sorties

Vous avez appris à éviter les erreurs courantes.

  • Les sauts de ligne restants perturbent %c ; utilisez une espace initiale
  • Passez toujours les adresses avec &
  • Utilisez %lf pour lire les doubles
  • Préférez fgets à gets et limitez %s
  • Vérifiez les valeurs de retour et videz la sortie
Gratuit pour commencer

Apprends C avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
39
Leçons
144

Questions Fréquemment Posées

La leçon « Pièges courants des entrées-sorties » est-elle gratuite ?

Oui — le texte complet de « Pièges courants des entrées-sorties » 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 courants des entrées-sorties » ?

Problèmes de tampon et de nouvelle ligne 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 courants des entrées-sorties » ?

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

  1. Spécificateurs de format de printf
  2. scanf et entrée
  3. Largeur, précision et indicateurs
  4. Pièges courants des entrées-sorties
← Retour à C Academy