C++ Academy · Les

Foutafhandeling en status

Controleer de streamstatus

Les 4 van 413 stappen

Foutafhandeling en status is een gratis C++ Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Statusbits van streams

Elke stream houdt zijn toestand bij met statusvlaggen:

goodbit: alles is in orde.
eofbit: het einde van het bestand is bereikt.
failbit: een logische fout, bijvoorbeeld een onjuiste indeling.
badbit: een ernstige invoer-/uitvoerfout.

#include <iostream>
#include <fstream>

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

Een stream testen

Een stream kan worden omgezet naar bool: de waarde is true wanneer de stream bruikbaar is. if (!in) detecteert een fout op een beknopte manier.

#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

Elke vlag heeft een opvraagmethode: good(), eof(), fail() en 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;
}

Mislukte extractie

Wanneer >> het verwachte type niet kan parsen, wordt failbit ingesteld en blijft het doelobject ongewijzigd.

#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;
}

De toestand wissen

Zodra een foutvlag is ingesteld, blijft de stream onbruikbaar totdat je clear() aanroept om de vlag te resetten.

#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;
}

Ongeldige invoer negeren

Gebruik na clear() ignore() om de problematische tekens te verwijderen voordat je het opnieuw probeert.

#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;
}

EOF van een fout onderscheiden

Controleer na het einde van een leeslus of deze normaal eindigde met eof() of door een echte fout met 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;
}

Na het openen controleren

Controleer de stream altijd onmiddellijk nadat je een bestand hebt geopend, zodat je direct faalt bij een ontbrekend of onleesbaar pad.

#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;
}

Uitzonderingen inschakelen

Je kunt een stream vragen om bij fouten een uitzondering te werpen met exceptions(). Zo worden stille fouten omgezet in onderschepbare std::ios_base::failure-uitzonderingen.

#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;
}

Het aantal gelezen bytes controleren

Na een binaire read geeft gcount() terug hoeveel bytes er daadwerkelijk zijn gelezen, zodat je onvolledig lezen kunt detecteren.

#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;
}

Een robuuste leeslus

Combineer de technieken: test de stream in de lus en bepaal daarna, wanneer de lus eindigt, of deze normaal is voltooid of door een fout is gestopt.

#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;
}

Snelle controle

Test je begrip van de status van streams.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd hoe je fouten in streams afhandelt:

statusvlaggen good/eof/fail/bad, die je opvraagt via hun methoden of door de stream als een bool te testen
clear() reset de toestand en ignore() verwijdert ongeldige invoer
onderscheid een normaal eof() van echte fouten; exceptions() kan een uitzondering werpen en gcount() controleert binaire leesacties

Volgende cursus: willekeurige getallen genereren met <random>.

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Foutafhandeling en status” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Foutafhandeling en status”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Foutafhandeling en status”?

Controleer de streamstatus Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Foutafhandeling en status”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy