Ввод и вывод в C++: потоки и форматирование без боли

Вы читаете число через std::cin >> x, пользователь вводит букву — и программа уходит в бесконечный цикл, печатая одно и то же приглашение. Или пытаетесь вывести число с двумя знаками после запятой и обвешиваете std::cout тремя манипуляторами, которые продолжают действовать на следующую строку. Обе проблемы решаются, если понять, как устроены потоки в C++ и что появилось в стандарте C++20. Здесь — рабочие приёмы для типичных задач ввода-вывода, с ценой каждого подхода.

Код проверялся на GCC 13 и Clang 17 в режиме -std=c++20. Там, где нужен именно C++20 (это std::format), это отмечено отдельно; всё остальное работает начиная с C++11.

Проблема номер один: битый ввод и состояние потока

Оператор >> при неудаче не бросает исключение и не возвращает мусор — он переводит поток в состояние ошибки и оставляет непрочитанные символы в буфере. Классический баг:

#include <iostream>

int main() {
    int age = 0;
    while (true) {
        std::cout << "Введите возраст: ";
        std::cin >> age;        // пользователь ввёл "abc"
        if (age > 0) break;
        // cin в состоянии fail, буква 'a' всё ещё в буфере
        // следующая итерация снова провалит чтение — бесконечный цикл
    }
}

После неудачного чтения нужно сделать две вещи: сбросить флаги ошибки и выкинуть застрявшие символы из буфера. Иначе следующее чтение снова провалится на том же байте.

#include <iostream>
#include <limits>

int main() {
    int age = 0;
    while (true) {
        std::cout << "Введите возраст: ";
        if (std::cin >> age && age > 0) break;

        std::cin.clear();  // сбрасываем флаги fail/bad
        // выбрасываем всё до конца строки, включая '\n'
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::cout << "Нужно целое положительное число.\n";
    }
    std::cout << "Возраст: " << age << '\n';
}

Проверка: введите abc — программа выведет сообщение об ошибке и попросит снова, а не зациклится. Введите 25 — выйдет из цикла.

Поток в C++ всегда в одном из четырёх состояний: good, eof, fail, bad. >> и функции чтения молча выставляют fail при неудаче — проверять результат нужно вам, компилятор об этом не напомнит.

Почему проверка if (std::cin >> age) вообще работает

Оператор >> возвращает ссылку на сам поток, а у потока есть неявное преобразование к bool (точнее, оператор explicit operator bool, который в условии срабатывает). Он возвращает true, если флаги fail и bad не выставлены. Поэтому if (std::cin >> age) читается как «удалось ли прочитать».

Проблема номер два: смешивание >> и getline

Оператор >> пропускает ведущие пробелы и переносы, но оставляет разделитель в буфере. std::getline читает до \n включительно. Стык этих двух даёт классическую ловушку:

#include <iostream>
#include <string>

int main() {
    int count = 0;
    std::string name;

    std::cin >> count;              // читает число, '\n' остаётся в буфере
    std::getline(std::cin, name);   // сразу натыкается на '\n' — читает пустую строку

    std::cout << "Имя: [" << name << "]\n";  // выведет пустые скобки
}

Решение — выкинуть остаток строки перед getline тем же ignore:

std::cin >> count;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::getline(std::cin, name);  // теперь читает настоящую строку

Проверка: введите 3, нажмите Enter, введите Мария — в скобках появится имя, а не пустота.

Форматирование вывода: манипуляторы против std::format

До C++20 форматированный вывод собирали из манипуляторов <iomanip>. Проблема в том, что большинство из них — липкие: заданный однажды формат действует на все последующие операции вывода, пока его не сбросят.

#include <iostream>
#include <iomanip>

int main() {
    double price = 1234.5;
    std::cout << std::fixed << std::setprecision(2)
              << price << '\n';   // 1234.50 — как ожидали

    std::cout << 42 << '\n';       // 42 — целое не тронуто
    std::cout << 7.0 << '\n';      // 7.00 — а вот тут сюрприз: fixed всё ещё активен
}

Флаг fixed и setprecision остаются в силе. setw, в отличие от них, действует только на следующую операцию — запомнить, что липкое, а что нет, само по себе источник ошибок.

std::format — C++20

С C++20 в стандартную библиотеку добавлен std::format (заголовок <format>). Формат задаётся строкой в фигурных скобках и не имеет состояния — он не влияет на другие вызовы.

#include <iostream>
#include <format>

int main() {
    double price = 1234.5;
    // {:.2f} — фиксированная точка, 2 знака после запятой
    std::cout << std::format("Цена: {:.2f}\n", price);   // Цена: 1234.50

    // выравнивание по правому краю в поле шириной 8
    std::cout << std::format("[{:>8}]\n", 42);            // [      42]

    // позиционные аргументы и заполнение нулями
    std::cout << std::format("{0:04d}-{1:02d}\n", 2024, 3); // 2024-03
}

Поддержка в компиляторах пришла не сразу: std::format полноценно доступен в GCC 13+, Clang 17+ (с libc++) и MSVC 19.29+. Если у вас старее — либо обновляйтесь, либо используйте библиотеку fmt, из которой std::format и вырос; синтаксис почти идентичен. В C++23 добавили std::print, который избавляет от std::cout <<, но это отдельная тема.

Когда что выбирать

Скорость: развязать cin и синхронизацию

По умолчанию потоки C++ синхронизированы с stdio из C, а cin связан с cout (перед каждым чтением сбрасывается буфер вывода). На больших объёмах ввода — например, в задачах на алгоритмы, где читаются сотни тысяч чисел — это ощутимо тормозит. Отключается двумя строками в начале main:

#include <iostream>

int main() {
    std::ios_base::sync_with_stdio(false);  // разрываем связь с stdio
    std::cin.tie(nullptr);                  // cin больше не сбрасывает cout

    // дальше обычное чтение через std::cin
}

Цена: после sync_with_stdio(false) нельзя безопасно смешивать cin/cout с scanf/printf в одной программе — порядок вывода станет непредсказуемым. И tie(nullptr) означает, что приглашения ко вводу могут не появиться на экране до момента чтения, если вывод буферизуется. В интерактивной программе, где вы печатаете «Введите:» и ждёте ответ, это заметно — там связь лучше не рвать.

Что ломается чаще всего

• Забыли clear() перед ignore(). После fail поток игнорирует все операции, включая сам ignore. Сначала clear(), потом ignore() — порядок важен.
• getline после >> читает пустую строку. Разобрано выше — нужен ignore между ними.
• Липкий setprecision. Задали точность для одного числа — она действует на все следующие. С std::format проблемы нет.
• Чтение до eof в цикле while (!cin.eof()). Флаг eof выставляется после неудачного чтения, а не до. Правильно проверять сам результат чтения: while (std::cin >> x).
• Ширина setw «не сработала» на второй раз. Она одноразовая — надо задавать перед каждым выводом.

Что делать дальше

Если проект уже на C++20 — переводите форматированный вывод на std::format и не возвращайтесь к iomanip: меньше скрытого состояния, меньше багов. Для чтения из файлов работают те же приёмы через std::ifstream — проверка состояния и ignore идентичны. Дальше стоит посмотреть в сторону std::print из C++23 (когда обновите компилятор) и std::from_chars из <charconv> для быстрого парсинга чисел без накладных расходов потоков. Разбор форматной строки std::format целиком — отдельная большая тема, здесь показаны только самые частые спецификаторы.