C++ Academy · Leçon

Gestion des erreurs et état

Vérifier l’état du flux

Gestion des erreurs et état 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.

Indicateurs d'état du flux

Chaque flux suit son état à l'aide d'indicateurs :

indicateur d'état correct : tout va bien.
indicateur de fin de fichier : la fin du fichier a été atteinte.
indicateur d'échec : une erreur logique s'est produite (format incorrect).
indicateur d'erreur grave : une erreur d'entrée-sortie sérieuse s'est produite.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in("missing_98765.txt");
    std::cout << std::boolalpha << "good: " << in.good() << '\n';
    return 0;
}

Tester un flux

Un flux se convertit en bool : il vaut true lorsqu'il est utilisable. if (!in) détecte brièvement un échec.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in("nope_55555.txt");
    if (!in) std::cout << "stream not usable\n";
    else std::cout << "ok\n";
    return 0;
}

good, eof, fail, bad

Chaque indicateur possède une méthode d'interrogation : good(), eof(), fail() et bad().

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("abc");
    int x;
    s >> x; // fails: not a number
    std::cout << std::boolalpha;
    std::cout << "fail: " << s.fail() << '\n';
    std::cout << "bad: " << s.bad() << '\n';
    return 0;
}

Extraction échouée

Lorsque >> ne peut pas analyser le type attendu, il définit failbit et laisse la cible inchangée.

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("hello");
    int n = -1;
    if (!(s >> n)) std::cout << "could not read an int, n stays " << n << '\n';
    return 0;
}

Réinitialiser l'état

Une fois qu'un indicateur d'échec est défini, le flux reste inutilisable jusqu'à ce que vous appeliez clear() pour le réinitialiser.

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("x 42");
    int n;
    s >> n;          // fails on 'x'
    s.clear();       // reset state
    std::string word;
    s >> word;       // now reads 'x'
    std::cout << "recovered: " << word << '\n';
    return 0;
}

Ignorer une entrée incorrecte

Après clear(), utilisez ignore() pour supprimer les caractères problématiques avant de réessayer.

#include <iostream>
#include <sstream>
#include <limits>

int main() {
    std::istringstream s("bad 100");
    int n;
    while (!(s >> n)) {
        s.clear();
        s.ignore(std::numeric_limits<std::streamsize>::max(), ' ');
    }
    std::cout << "read " << n << '\n';
    return 0;
}

Distinguer la fin du fichier d'une erreur

Après la fin d'une boucle de lecture, vérifiez s'il s'agit d'une fin normale avec eof() ou d'un véritable échec avec bad().

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("1 2 3");
    int x;
    while (s >> x) {}
    std::cout << std::boolalpha << "reached eof: " << s.eof() << '\n';
    std::cout << "hardware error: " << s.bad() << '\n';
    return 0;
}

Vérifier après l'ouverture

Vérifiez toujours le flux juste après l'ouverture d'un fichier afin d'échouer rapidement si le chemin est manquant ou illisible.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in("absent_11111.txt");
    if (!in.is_open()) {
        std::cout << "open failed, aborting\n";
        return 1;
    }
    std::cout << "never reached\n";
    return 0;
}

Activer les exceptions

Vous pouvez demander à un flux de lever des exceptions en cas d'erreur avec exceptions(), transformant ainsi les échecs silencieux en std::ios_base::failure interceptables.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in;
    in.exceptions(std::ios::failbit);
    try {
        in.open("ghost_22222.txt");
    } catch (const std::exception& e) {
        std::cout << "caught open failure\n";
    }
    return 0;
}

Valider le nombre d'octets lus

Après un read binaire, gcount() indique combien d'octets ont réellement été lus, ce qui permet de détecter les lectures incomplètes.

#include <iostream>
#include <fstream>

int main() {
    int v = 9;
    std::ofstream("g.bin", std::ios::binary).write(reinterpret_cast<const char*>(&v), sizeof(v));
    int out;
    std::ifstream in("g.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(&out), sizeof(out));
    std::cout << "read " << in.gcount() << " bytes\n";
    return 0;
}

Une boucle de lecture robuste

Combinez ces techniques : testez le flux dans la boucle, puis, à sa fin, distinguez une terminaison normale d'une erreur.

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("5 10 15");
    int total = 0, x;
    while (s >> x) total += x;
    if (s.eof()) std::cout << "sum = " << total << " (clean)\n";
    else std::cout << "error during read\n";
    return 0;
}

Vérification rapide

Évaluez votre compréhension de l'état des flux.

Récapitulatif

Vous avez appris à gérer les erreurs des flux :

les indicateurs d'état good/eof/fail/bad, interrogés via leurs méthodes ou en testant le flux comme un booléen
clear() réinitialise l'état et ignore() supprime l'entrée incorrecte
distinguez une fin normale avec eof() des véritables erreurs ; exceptions() peut lever une exception et gcount() valide les lectures binaires

Prochain cours : générer des nombres aléatoires avec <random>.

Questions Fréquemment Posées

La leçon « Gestion des erreurs et état » est-elle gratuite ?

Oui — le texte complet de « Gestion des erreurs et état » 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 « Gestion des erreurs et état » ?

Vérifier l’état du flux 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 « Gestion des erreurs et état » ?

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