Ввод и вывод в C++: на что смотреть новичку

Вы написали программу на C++, которая просит ввести число, а потом имя. Число она читает нормально, а вот имя пропускает — как будто пользователь ничего не набрал. Или наоборот: программа медленно выводит миллион строк, хотя данных всего ничего. Оба симптома — про потоки ввода-вывода, и оба лечатся за пару минут, если понимать, что происходит. Разбираем на компиляторе с поддержкой C++17 и новее (GCC 11+, Clang 14+, MSVC 2022) — весь код ниже собирается и запускается как есть.

Что читаете и куда пишете

В C++ ввод и вывод идут через потоки. Стандартных четыре: std::cin (клавиатура), std::cout (экран), std::cerr (ошибки, без буферизации), std::clog (ошибки, с буферизацией). Все объявлены в заголовке <iostream>. Оператор >> читает из потока, << пишет в поток.

#include <iostream>
#include <string>

int main() {
    int age;
    std::cout << "Сколько вам лет? ";
    std::cin >> age;
    std::cout << "Через год будет " << age + 1 << '\n';
}

Оператор >> сам разбирает типы: для int читает число, для std::string — слово, для double — число с дробной частью. Пробелы, табуляции и переводы строк он пропускает перед чтением. Это удобно и это же источник первой ловушки.

Главная ловушка: cin >> и getline не дружат сразу

Оператор >> читает слово и оставляет символ перевода строки в буфере. Пользователь нажал Enter — этот \n никуда не делся. Следующий вызов std::getline, который читает строку до перевода строки, тут же натыкается на этот \n и возвращает пустую строку. Классика:

#include <iostream>
#include <string>

int main() {
    int age;
    std::string name;

    std::cout << "Возраст: ";
    std::cin >> age;              // читает число, \n остаётся в буфере

    std::cout << "Имя: ";
    std::getline(std::cin, name); // хватает тот самый \n, name пустое

    std::cout << "[" << name << "]\n";
}

На экране получится [] — программа даже не даст ввести имя. Лечится одной строкой: перед getline нужно выбросить остаток текущей строки из буфера.

#include <iostream>
#include <string>
#include <limits>   // нужен для numeric_limits

int main() {
    int age;
    std::string name;

    std::cout << "Возраст: ";
    std::cin >> age;

    // выбросить всё до конца строки, включая сам \n
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

    std::cout << "Имя: ";
    std::getline(std::cin, name);

    std::cout << "[" << name << "]\n";
}

Метод ignore читает и отбрасывает символы, пока не выбросит указанное количество (max() — фактически без лимита) или не встретит '\n'. После этого буфер чист, и getline читает то, что вы ждёте.

Правило, которое сэкономит часы: если в программе смешиваются >> и getline, между ними почти всегда нужен cin.ignore. Не помните — просто не смешивайте: читайте всё через getline, а числа парсите отдельно через std::stoi.

endl или '\n' — есть разница

Оба выводят перевод строки, но std::endl вдобавок делает flush — принудительно сбрасывает буфер вывода на экран или в файл. Для одной-двух строк это незаметно. В цикле на десятки тысяч итераций разница ощутимая: каждый endl — это отдельная операция сброса.

#include <iostream>

int main() {
    // медленно: сброс буфера на каждой из 100000 строк
    for (int i = 0; i < 100000; ++i)
        std::cout << i << std::endl;

    // быстро: буфер сбрасывается сам, когда заполнится
    for (int i = 0; i < 100000; ++i)
        std::cout << i << '\n';
}

Практическое правило простое: в 99% случаев пишите '\n'. Явный endl нужен, только когда вам действительно важно, чтобы вывод появился прямо сейчас — например, перед долгой операцией или перед вводом, чтобы приглашение точно было видно.

Что делать с неправильным вводом

Пользователь на вопрос «сколько вам лет» ввёл abc. Оператор >> не смог разобрать это как int, поток перешёл в состояние ошибки (failbit), а переменная осталась с прежним (мусорным) значением. Хуже того: abc остался в буфере, и если у вас цикл чтения — он закрутится вхолостую навсегда.

Проверять результат чтения нужно так — поток в булевом контексте возвращает false, если чтение не удалось:

#include <iostream>
#include <limits>

int main() {
    int number;
    std::cout << "Введите целое число: ";

    while (!(std::cin >> number)) {
        std::cin.clear(); // сбросить флаг ошибки
        // выбросить весь испорченный ввод до конца строки
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::cout << "Это не число. Ещё раз: ";
    }

    std::cout << "Принято: " << number << '\n';
}

Два метода в паре обязательны: clear() возвращает потоку рабочее состояние, а ignore() убирает из буфера то, что не разобралось. Без clear() все дальнейшие чтения будут игнорироваться, потому что failbit никуда не денется.

Проверка через EOF

Когда читаете неизвестное число значений подряд (например, из файла или до конца ввода), проверяйте сам факт удачного чтения в условии цикла, а не отдельно:

int value;
long long sum = 0;
while (std::cin >> value)   // цикл закончится на EOF или на нечисле
    sum += value;
std::cout << sum << '\n';

В терминале конец ввода задаётся сочетанием Ctrl+D (Linux, macOS) или Ctrl+Z и Enter (Windows).

Мелочи, которые ловят всех

• std::cin >> name для строки читает одно слово. Ввод «Иван Петров» положит в name только «Иван», а «Петров» останется в буфере. Нужна вся строка целиком — берите getline.
• Приглашение без flush может не показаться до ввода. Если пишете cout << "Имя: " без перевода строки, а сразу ждёте ввод — на некоторых системах текст «Имя: » повиснет в буфере. Добавьте << std::flush или переведите строку.
• Смешение с C-функциями. Не мешайте printf/scanf и cout/cin в одной программе без нужды — порядок вывода может нарушиться из-за раздельных буферов.
• Ширина и формат. Для выравнивания чисел и таблиц подключите <iomanip> и используйте std::setw, std::setprecision, std::fixed. Без этого дробные числа выводятся с точностью по умолчанию.

Таблица: чем читать что

Про скорость: sync_with_stdio

Если решаете задачи с большим объёмом ввода (десятки-сотни тысяч чисел) и cin тормозит, добавьте в начало main две строки. Они отключают синхронизацию потоков C++ с потоками C и развязывают cin и cout:

std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);

После sync_with_stdio(false) нельзя смешивать cin/cout с scanf/printf — порядок вывода станет непредсказуемым. Для обычных интерактивных программ этот приём не нужен и может даже навредить: приглашения перестанут вовремя появляться, потому что cout больше не сбрасывается перед чтением из cin.

Если не получилось

• getline вернул пустую строку. Перед ним был >>. Вставьте cin.ignore(...), как показано выше.
• Программа не ждёт ввод, а сразу завершается. Поток в состоянии ошибки после неудачного чтения — вы забыли cin.clear().
• Цикл чтения крутится бесконечно. Вы читаете в int, но не убираете нечисло из буфера. Нужна пара clear() + ignore().
• Дробные числа выводятся странно (1e+06 вместо 1000000). Подключите <iomanip> и примените std::fixed.
• error: 'cin' was not declared. Забыли #include <iostream> или пишете cin без std::.

Что дальше

Освоив базовый ввод-вывод, посмотрите в сторону std::stringstream из <sstream> — он позволяет разбирать строку по частям и собирать текст без обращения к консоли. Дальше — работа с файлами через std::ifstream и std::ofstream: интерфейс тот же, что у cin/cout, поэтому все привычки переносятся один в один. И привыкайте всегда проверять результат чтения: программа, которая не спотыкается о кривой ввод, отличается от учебной именно этим.