Стани потоку: good/eof/fail/bad

1. Навіщо думати про стан потоку, якщо ви читаєте файл

Коли ви починаєте читати файл, усе здається простим: відкрили std::ifstream, запустили цикл, обробили дані. Але на практиці читання може завершитися по-різному: файл міг скінчитися — і це нормально; дані могли виявитися «не того формату», і тоді це вже помилка у вхідних даних; або ж могла статися серйозна проблема введення/виведення, наприклад під час читання з пошкодженого носія. Без розуміння стану потоку ви бачите лише симптом: «цикл зупинився».

Важлива думка така: потік — це не просто «шланг, яким течуть байти». Це обʼєкт, який після кожної операції запамʼятовує, чи все минуло успішно. І якщо ви навчитеся читати ці «нотатки на полях», то зможете писати код, який не вдає, ніби все гаразд, коли насправді файл пошкоджений, формат порушено або ви читаєте зовсім не те, що думаєте.

Якщо спростити, мета цієї лекції — навчитися розрізняти три ситуації: «усе дочитали до кінця», «не змогли прочитати, бо дані не підходять» і «не змогли прочитати, бо стався збій введення/виведення».

Прапорці стану потоку: goodbit/eofbit/failbit/badbit

У потоків є набір прапорців стану, або бітів, які встановлюються після операцій читання й запису. Не треба запамʼятовувати їх як заклинання — краще уявити, що в потоку є маленька панель приладів. Поки все гаразд, горить зелена лампочка. Коли доходите до кінця файлу, загоряється «EOF». Коли формат не відповідає очікуваному — «FAIL». Коли стається серйозна проблема — «BAD».

Ось наочна таблиця — без спроби «втиснути сюди весь стандарт»:

good()

eof()

fail()

bad()

Є одна тонкість, на якій новачки часто спотикаються: fail() — поняття ширше, ніж просто «неправильний формат». Наприклад, спроба прочитати число після кінця файлу теж призводить до fail(). Тобто «EOF» і «FAIL» нерідко йдуть у парі — просто тому, що про EOF ви дізнаєтеся лише після невдалої спроби читання.

2. Перевірка читання і правильні цикли

if (in) і приведення потоку до bool

Щоб щоразу не писати «перевірити всі лампочки», C++ пропонує зручне скорочення: потік можна перевіряти як логічне значення. Умова if (in) означає приблизно «потік зараз у придатному для читання стані», а if (!in) — «щось пішло не так».

Важливо розуміти, що логічна перевірка потоку за змістом ближча до «чи немає стану fail», ніж до «чи все ідеально». Тому інколи варто явно перевірити eof() або bad(), щоб точніше зрозуміти, що саме сталося.

Невеликий приклад: читаємо одне число й виводимо, чи вдалося це зробити.

#include <fstream>
#include <iostream>

int main() {
    std::ifstream in("numbers.txt");

    int x = 0;
    if (in >> x) {
        std::cout << "Зчитано x = " << x << '\n';
    } else {
        std::cout << "Не вдалося прочитати x\n";
    }
}

Зверніть увагу на стиль: ви не робите in >> x, а потім лише «пригадуєте перевірити»; натомість ви перевіряєте результат самої операції. Це один з основних принципів роботи з потоками: «робимо — і відразу перевіряємо».

Якщо хочете побачити прапорці явно, наприклад під час налагодження, можна вивести ці «лампочки» в консоль:

#include <fstream>
#include <iostream>

int main() {
    std::ifstream in("numbers.txt");
    int x = 0;

    in >> x;

    std::cout << "good=" << in.good()
              << " eof=" << in.eof()
              << " fail=" << in.fail()
              << " bad=" << in.bad() << '\n';
}

Таку перевірку корисно тримати в голові як «діагностичний ліхтарик». Не обовʼязково виводити це завжди, але коли щось раптом зупинилося, це швидкий спосіб зрозуміти, у якому саме стані перебуває потік.

Читаємо прямо в умові циклу

Найпоширеніша помилка під час читання — будувати цикл із припущення, що читання завжди спрацює, а вже потім намагатися розбиратися з наслідками. Правильний підхід протилежний: цикл має повторюватися доти, доки читання успішне. Тобто операція читання має стояти в умові циклу.

Якщо читаєте числа через >>, це має такий вигляд:

#include <fstream>
#include <iostream>

int main() {
    std::ifstream in("numbers.txt");

    long long sum = 0;
    int x = 0;
    while (in >> x) {
        sum += x;
    }

    std::cout << "sum=" << sum << '\n'; // наприклад: sum=60
}

Якщо читаєте построково, то аналогічно:

#include <fstream>
#include <iostream>
#include <string>

int main() {
    std::ifstream in("lines.txt");

    std::string line;
    while (std::getline(in, line)) {
        std::cout << "рядок: " << line << '\n';
    }
}

Чому так важливо читати саме в умові? Тому що потік повідомляє вам правду саме в момент спроби читання. Якщо ж ви спочатку запускаєте цикл, а вже потім читаєте, то легко можете отримати зайву ітерацію, обробити сміття або повторно використати старе значення.

Чому while (!in.eof()) — пастка

Із eof() новачки зазвичай знайомляться через непорозуміння. Дуже хочеться написати так: «доки не кінець файлу — читаємо». Звучить логічно. Але eof() стає true лише після того, як ви спробували прочитати за межами файлу.

Тобто цикл while (!in.eof()) майже гарантовано дає зайву ітерацію: ви зайдете в цикл, виконаєте невдале читання, а потім, цілком можливо, обробите дані, яких насправді вже немає.

Класичний невдалий приклад:

#include <fstream>
#include <iostream>

int main() {
    std::ifstream in("numbers.txt");

    long long sum = 0;
    int x = 0;

    while (!in.eof()) {
        in >> x;
        sum += x; // x міг не змінитися, якщо читання не вдалося
    }

    std::cout << "sum=" << sum << '\n';
}

Якщо останній in >> x не зміг прочитати число — наприклад, тому що файл уже скінчився, — змінна x зазвичай зберігає попереднє значення. І ви ще раз додасте до суми «старе значення». У результаті зʼявляється баг, який виглядає як «чому сума інколи більша на одне число?». Це саме той випадок, коли програміст починає підозрювати примар у ноутбуці.

Правильний цикл — лише через while (in >> x) або while (std::getline(...)), як показано вище.

3. EOF — не помилка: відрізняємо кінець файлу від збою

Коли цикл читання завершується, виникає головне запитання: «усе вже прочитано чи щось зламалося?» Саме тут eof(), fail() і bad() треба використовувати усвідомлено.

Типовий підхід після читання окремих значень такий: «якщо bad() — це проблема введення/виведення; якщо fail() і не eof() — це помилка формату».

#include <fstream>
#include <iostream>

int main() {
    std::ifstream in("numbers.txt");

    int x = 0;
    while (in >> x) {
        // обробка
    }

    if (in.bad()) {
        std::cerr << "I/O-помилка під час читання\n";
        return 1;
    }

    if (in.fail() && !in.eof()) {
        std::cerr << "Помилка формату: очікувалося число\n";
        return 1;
    }

    // сюди ми потрапляємо, якщо читання завершилося нормально, зазвичай через EOF
}

Тут важливо вловити логіку: EOF часто означає штатне завершення читання, а от «fail без EOF» — це ознака того, що дані не відповідають очікуваному формату. Наприклад, ви читали int, а у файлі трапилося слово "cat".

Для std::getline картина простіша: якщо std::getline повернув false, це міг бути як EOF, так і збій читання. Часто достатньо перевірити if (!in.eof()), щоб зрозуміти: зупинка сталася не з «природної причини».

4. Що означає fail() і як відновитися

fail() у навчальних задачах найчастіше означає: «ми очікували одне, а отримали інше». Наприклад, очікуємо число, а там рядок. Або очікуємо три поля, а рядок порожній. Це не «катастрофа диска», а радше ситуація на кшталт «користувач або файл містить щось не те».

Ось простий сценарій. Припустімо, у файлі йдуть числа, але раптом трапляється слово:

10 20 cat 30

Код:

#include <fstream>
#include <iostream>

int main() {
    std::ifstream in("mixed.txt");

    int x = 0;
    while (in >> x) {
        std::cout << "x=" << x << '\n'; // x=10, x=20
    }

    if (in.fail() && !in.eof()) {
        std::cout << "Зупинка: це не число\n"; // Зупинка: це не число
    }
}

Добре, проблему виявлено. А чи можна «продовжити читання» після fail()? Іноді так, але спершу треба вирішити: що саме ви пропускаєте, щоб знову синхронізуватися з потоком. Якщо ви просто викличете clear(), а сміття у вході залишиться, то легко потрапите в нескінченний цикл: знову пробуєте прочитати число, знову fail(), знову clear()… і так доти, доки не вичерпається терпіння.

Дуже поширений «ремонтний» прийом — скинути стан і пропустити рядок до '\n'. Він добре працює, коли формат такий: «один запис = один рядок».

#include <fstream>
#include <iostream>
#include <limits>

int main() {
    std::ifstream in("mixed_lines.txt");

    int x = 0;
    while (true) {
        if (in >> x) {
            std::cout << "x=" << x << '\n';
            continue;
        }

        if (in.eof() || in.bad()) break;

        in.clear();
        in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
}

Це не «магія», а дисципліна: якщо читання зламалося, ви маєте або зупинитися, або пропустити проблемний фрагмент так, щоб наступна спроба читання справді мала шанс.

5. Що означає bad(): коли краще зупинитися

Якщо fail() часто означає «дані не підходять», то bad() — це натяк, що проблема глибша: помилка введення/виведення, пошкодження буфера або щось інше, після чого продовжувати читання зазвичай уже безглуздо. У реальних системах таке трапляється нечасто, але в навчальному коді корисно тримати в голові просте правило: bad() — це привід зупинитися й максимально прямо повідомити про помилку.

Психологічно bad() зручно розуміти так: fail() — «я не зміг прочитати число», а bad() — «я вже не впевнений, що цей потік узагалі може далі нормально працювати».

Тому в акуратно написаних завантажувачах, та й у звичайних утилітах, перевірки зазвичай ідуть у такому порядку: спочатку bad(), потім fail(), і лише потім — «а може, це просто EOF».

6. Схема: як сприймати читання з файлу як алгоритм

Щоб не тримати все це в голові як безлад із if-ів, корисно уявляти читання як алгоритм із розгалуженнями. Це особливо допомагає, коли ви налагоджуєте ситуацію «чому воно зупинилося».

flowchart TD
    A[Початок: потік відкрито] --> B{Операція читання успішна?}
    B -->|так| C[Опрацювати дані]
    C --> B
    B -->|ні| D{"bad()?"}
    D -->|так| E[Серйозна помилка введення/виведення -> зупинитися]
    D -->|ні| F{"fail() && !eof()?"}
    F -->|так| G[Помилка формату -> повідомити / вирішити, що робити]
    F -->|ні| H["Нормальне завершення читання (зазвичай EOF)"]

Ця схема не вимагає запамʼятовувати біти — достатньо виробити звичку: після зупинки циклу завжди ставити запитання «чому».

7. Приклад: TaskBook — завантаження задач построково

Щоб тема не залишалася «у вакуумі», продовжимо умовний навчальний застосунок TaskBook — невеликий консольний список задач. Раніше в ньому були команди й робота з даними в памʼяті, а тепер ви хочете завантажувати задачі з файлу. Формат зробімо простим: один рядок — одна задача:

id;done;title

Наприклад:

1;0;Купити молоко
2;1;Прочитати книжку про C++ (необовʼязково)

Почнемо з моделі:

#include <string>

struct Task {
    int id{};
    bool done{};
    std::string title;
};

Тепер зробімо дуже простий парсер одного рядка, без фанатизму. Тут важливо не «ідеально розпарсити все», а показати звʼязок зі станом потоку: рядок читаємо через std::getline, а помилки формату фіксуємо окремо.

#include <sstream>
#include <string>

bool parse_task_line(const std::string& line, Task& out) {
    std::stringstream ss(line);

    int id = 0;
    int done_int = 0;
    if (!(ss >> id)) return false;
    if (ss.get() != ';') return false;
    if (!(ss >> done_int)) return false;

    out.id = id;
    out.done = (done_int != 0);
    out.title = line.substr(line.find_last_of(';') + 1);
    return true;
}

Так, цей парсер неідеальний: наприклад, він не перевіряє всі граничні випадки. Але це нормально, бо мета лекції — не парсинг, а розуміння того, чому зупиняється читання. Парсер тут потрібен лише як приклад для построкового читання.

Тепер — власне завантаження. І ось тут застосовується головний принцип: читаємо в циклі while (std::getline(...)), а після циклу слід відрізнити EOF від проблеми читання.

#include <fstream>
#include <string>
#include <vector>

bool load_tasks(const std::string& filename,
                std::vector<Task>& tasks,
                std::string& error) {
    std::ifstream in(filename);
    if (!in) { error = "не вдалося відкрити файл"; return false; }

    std::string line;
    while (std::getline(in, line)) {
        Task t;
        if (!parse_task_line(line, t)) { error = "некоректний запис"; return false; }
        tasks.push_back(t);
    }

    if (!in.eof()) { error = "помилка читання"; return false; }
    return true;
}

Зверніть увагу на зміст if (!in.eof()) після циклу. Цикл std::getline міг зупинитися, бо настав EOF, — і це нормально; а міг зупинитися через помилку читання — і це вже ненормально. Така перевірка — мінімальна дисципліна для «дорослого» коду.

І міні-main, який показує, як це може виглядати в програмі:

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<Task> tasks;
    std::string error;

    if (!load_tasks("tasks.txt", tasks, error)) {
        std::cerr << "Не вдалося завантажити: " << error << '\n';
        return 1;
    }

    std::cout << "Завантажено задач: " << tasks.size() << '\n'; // Завантажено задач: 2
}

Навіть у такому маленькому прикладі видно: розрізняти причини зупинки читання — це не «краса», а спосіб не брехати самим собі. Бо якщо std::getline зупинився через помилку, а ви сприйняли це як EOF, то отримаєте «тихо пошкоджені дані». А це майже завжди гірше, ніж явне падіння.

8. Типові помилки під час роботи зі станом потоків

Помилка № 1: цикл while (!eof()).
Він виглядає логічно, але створює зайву ітерацію й провокує обробку «старих» значень, бо eof() встановлюється лише після спроби читання за кінець файлу. Це один з тих багів, коли програма майже завжди працює, аж доки одного дня не починає видавати суму на 10 більше, і ви пів години звинувачуєте математику.

Помилка № 2: «цикл завершився — отже, все нормально».
Новачки часто сприймають зупинку while (in >> x) як природне завершення. Але цикл однаково зупиниться і на EOF, і в ситуації «зустріли слово замість числа», і на проблемі введення/виведення. Якщо після циклу не розрізняти bad() та fail() && !eof(), програма мовчки сприйматиме сміття як норму.

Помилка № 3: після fail() викликають clear(), але не прибирають причину fail.
Скинути прапорець недостатньо. Якщо на вході лежить той самий символ або токен, який знову спричиняє помилку, наступне введення знову завершиться fail(). Це легко перетворюється на нескінченний цикл «прочитати → fail → clear → прочитати → fail…». Після clear() майже завжди потрібно або пропустити проблемну частину входу, або припинити обробку.

Помилка № 4: плутанина між «помилкою даних» і «помилкою введення/виведення».
fail() часто означає проблему формату, тобто дані не відповідають очікуванню, а bad() — проблему самого введення/виведення. Це різні класи помилок. У першому випадку ви зазвичай повідомляєте «некоректний формат файлу», у другому — «помилка читання файлу». Якщо змішувати їх в одне розмите «щось пішло не так», діагностика стає складнішою і для вас, і для користувача.

Помилка № 5: не перевіряти !eof() після циклу std::getline.
Під час построкового читання легко забути, що std::getline може зупинитися не лише через EOF. Якщо ви не перевіряєте !in.eof(), то ризикуєте сприйняти «обірване введення» як нормальний кінець файлу — особливо неприємно, якщо файл раптом читається з мережевого диска або з нестабільного середовища.