C++ Academy · Lezione

Gestione degli errori e stato

Controllare lo stato dello stream

Gestione degli errori e stato è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Bit di stato dello stream

Ogni stream tiene traccia della propria condizione tramite flag di stato:

goodbit: tutto funziona correttamente.
eofbit: è stata raggiunta la fine del file.
failbit: si è verificato un errore logico, ad esempio un formato errato.
badbit: si è verificato un errore I/O grave.

#include <iostream>
#include <fstream>

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

Verifica di uno stream

Uno stream può essere convertito in bool: vale true quando è utilizzabile. if (!in) rileva l'errore in modo conciso.

#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

Ogni flag dispone di un metodo di verifica: good(), eof(), fail() e 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;
}

Estrazione non riuscita

Quando >> non riesce ad analizzare il tipo previsto, imposta failbit e lascia invariato il valore di destinazione.

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

Azzeramento dello stato

Una volta impostato un flag di errore, lo stream rimane inutilizzabile finché non si chiama clear() per reimpostarlo.

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

Ignorare l'input errato

Dopo clear(), usi ignore() per scartare i caratteri errati prima di riprovare.

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

Distinzione tra EOF ed errore

Al termine di un ciclo di lettura, verifichi se la fine è stata raggiunta correttamente con eof() o se si è verificato un vero errore con 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;
}

Verifica dopo l'apertura

Verifichi sempre lo stream subito dopo aver aperto un file, così da rilevare immediatamente un percorso mancante o non leggibile.

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

Abilitazione delle eccezioni

Può chiedere a uno stream di generare eccezioni in caso di errore con exceptions(), trasformando gli errori silenziosi in std::ios_base::failure intercettabili.

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

Convalida del numero di letture

Dopo un read binario, gcount() indica quanti byte sono stati effettivamente letti, consentendo di rilevare le letture incomplete.

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

Un ciclo di lettura robusto

Combini le tecniche: testi lo stream nella condizione del ciclo e, al termine, distingua una conclusione corretta da un errore.

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

Verifica rapida

Verifichi la Sua comprensione dello stato degli stream.

Riepilogo

Ha imparato a gestire gli errori degli stream:

i flag di stato good/eof/fail/bad possono essere verificati tramite i relativi metodi o testando lo stream come un valore bool
clear() reimposta lo stato e ignore() scarta l'input errato
distingua un eof() corretto dagli errori reali; exceptions() può generare eccezioni e gcount() convalida le letture binarie

Corso successivo: generazione di numeri casuali con <random>.

Domande Frequenti

La lezione «Gestione degli errori e stato» è gratuita?

Sì — il testo completo di «Gestione degli errori e stato» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Gestione degli errori e stato»?

Controllare lo stato dello stream Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Gestione degli errori e stato»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy