C++ Academy · Lekcja

Obsługa błędów i stan

Sprawdzaj stan strumienia

Obsługa błędów i stan to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Flagi stanu strumienia

Każdy strumień śledzi swój stan za pomocą flag:

goodbit: wszystko jest w porządku.
eofbit: osiągnięto koniec pliku.
failbit: wystąpił błąd logiczny, na przykład nieprawidłowy format.
badbit: wystąpił poważny błąd wejścia lub wyjścia.

#include <iostream>
#include <fstream>

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

Sprawdzanie strumienia

Strumień można przekonwertować na bool: ma wartość true, gdy nadaje się do użycia. Warunek if (!in) zwięźle wykrywa błąd.

#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

Każda flaga ma odpowiadającą jej metodę sprawdzającą: good(), eof(), fail() i 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;
}

Nieudana ekstrakcja

Gdy operator >> nie może zinterpretować oczekiwanego typu, ustawia failbit i pozostawia wartość docelową bez zmian.

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

Czyszczenie stanu

Po ustawieniu flagi błędu strumień pozostaje nieużyteczny, dopóki nie zostanie wywołane clear(), które resetuje jego stan.

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

Ignorowanie nieprawidłowych danych

Po wywołaniu clear() należy użyć ignore(), aby odrzucić nieprawidłowe znaki przed ponowną próbą.

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

Rozróżnianie końca pliku od błędu

Po zakończeniu pętli odczytu należy sprawdzić, czy zakończyła się ona poprawnie przez eof(), czy też wystąpił rzeczywisty błąd 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;
}

Sprawdzanie po otwarciu

Zawsze należy sprawdzić strumień bezpośrednio po otwarciu pliku, aby szybko wykryć brakującą lub nieczytelną ścieżkę.

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

Włączanie wyjątków

Można zażądać, aby strumień zgłaszał wyjątki w razie błędów, używając exceptions(). Dzięki temu ciche niepowodzenia zostaną zamienione na przechwytywalne wyjątki std::ios_base::failure.

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

Sprawdzanie liczby odczytanych danych

Po binarnym wywołaniu read metoda gcount() zwraca liczbę faktycznie odczytanych bajtów, co pozwala wykrywać niepełne odczyty.

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

Solidna pętla odczytu

Należy połączyć te techniki: sprawdzać strumień w warunku pętli, a po jej zakończeniu rozróżnić poprawne zakończenie od błędu.

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

Szybki test

Proszę sprawdzić swoją wiedzę na temat stanu strumienia.

Podsumowanie

Poznali Państwo obsługę błędów strumienia:

flagi stanu good/eof/fail/bad można sprawdzać za pomocą odpowiadających im metod lub przez sprawdzenie strumienia jako wartości boolowskiej
clear() resetuje stan, a ignore() odrzuca nieprawidłowe dane
należy rozróżniać poprawny koniec pliku eof() od rzeczywistych błędów; exceptions() może zgłaszać wyjątki, a gcount() sprawdza poprawność odczytów binarnych

Następny kurs: generowanie liczb losowych za pomocą <random>.

Często zadawane pytania

Czy lekcja „Obsługa błędów i stan” jest bezpłatna?

Tak — pełny tekst „Obsługa błędów i stan” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obsługa błędów i stan”?

Sprawdzaj stan strumienia Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Obsługa błędów i stan”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy