std cin c что это

Насколько медленны iostreams?

Потоки ввода-вывода в стандартной библиотеке C++ просты в использовании, типобезопасны, устойчивы к утечке ресурсов, и позволяют простую обработку ошибок. Однако, за ними закрепилась репутация «медленных». Этому есть несколько причин, таких как широкое использование динамической аллокации и виртуальных функций. Вообще, потоки — одна из самых древних частей стандартной библиотеки (они начали использоваться примерно в 1988 году), и многие решения в них сейчас воспринимаются как «спорные». Тем не менее, они широко используются, особенно когда надо написать какую-то простую программу, работающую с текстовыми данными.

Вопрос производительности iostreams не праздный. В частности, с проблемой производительности консольного ввода-вывода можно столкнуться в системах спортивного программирования, где даже применив хороший алгоритм, можно не пройти по времени только из-за ввода-вывода. Я также встречался с этой проблемой при обработке научных данных в текстовом формате.

Сегодня в комментариях у посту возникло обсуждение о медленности iostreams. В частности, freopen пишет

Забавно смотреть на ваши оптимизации, расположенные по соседству со считыванием через cin 🙂

Можно заменить на getchar_unlocked() для *nix или getchar() для всех остальных.
getchar_unlocked > getchar > scanf > cin, где «>» означает быстрее.

В этом посте я развею и подтвержу некоторые мифы и дам пару рекомендаций.

Все измерения в этом посте приведены для системы Ubuntu 14.10 с компилятором GCC 4.9.1, компилировалось с ключами

Запуск проводился на ноутбуке с процессором Intel Core2 Duo P8600 (2.4 ГГц).

Постановка задачи

В спортивном программировании, как и в UNIX-way, обычно входные данные подаются на входной поток. Итак, задача:

На входной поток (stdin) поступает много неотрицательных целых чисел по одному на строке. Программа должна вывести максимальное из входных чисел.

Сформируем входные данные

В файл data мы записали 10 миллионов последовательных целых чисел, общим объёмом 76 мегабайт.
Запускать программу мы будем так

1. scanf

Решим задачу с использованием старого доброго scanf.

Время работы: 1.41 c

2. Наивный std::cin

Теперь решим задачу самым простым способом при помощи iostreams:

Время работы: 4.41 c
Ого! Потоки оказались медленнее чем scanf в 3 раза! То есть выходит, что iostream оказываются действительно никуда не годится по скорости?

3. Быстрый std::cin

На самом деле, чтобы исправить ситуацию, достаточно добавить в программу одну единственную строчку. В самом начале функции main вставим:

Все последующие варианты с использованием std::cin будут использовать эту оптимизацию.

4. Наивный std::istringstream

Помимо ввода из файла, стандартная библиотека предоставляет также классы для ввода из строки с таким же интерфейсом. Посмотрим, насколько это медленно. Будем читать из входного потока по одной строке, а затем парсить её с помощью std::istringstream :

Время работы: 7.21 c
Очень медленно!

5. Переиспользование std::istringstream

Может показаться удивительным, но самое медленное в istringstream — это его создание. А мы создаём для каждой входной строки заново. Попробуем переиспользовать один и тот же объект:

Обратите внимание, что нужны 2 вызова — clear, чтобы сбросить флаги состояния, и str, чтобы задать новый буфер, из которого будет происходить чтение.

Время работы: 2.16 c
Это другое дело. Это ожидаемо медленнее, чем чтение напрямую из std::cin (данные проходят 2 раза через классы потоков), но не катастрофично.

6. Хотим ещё быстрее! (getchar/getchar_unlocked)

7. C++11: std::stoi

Время работы: 1.04 c
Это самый быстрый стандартный способ чтения целых чисел. (А для чисел с плавающей точкой есть аналогичные функции stof/stod).

8. Бонус: Чтение большими блоками + Boost::Spirit

Время работы: 0.18 c
Это рекорд!

Результаты и советы

Время работы:

* — Измерения на файле со 100 миллионами чисел (размер файла 848 мегабайт).

Рекомендации:

Update 1. По совету Lol4t0 добавлен метод номер 7.
Update 2. В таблицу добавлены времена выполнения на clang+libc++ (версия 3.5.0, выполнялось на той же системе). Видно, что производительность потоков очень плохая, да к тому же трюк с выключением синхронизации не работает. В результате stoi оказывается в 2 раза медленнее чем scanf.
Update 3. Добавлен вариант номер 8: чтение большими блоками и разбор с помощью Boost::Spirit. И это чемпион!

Источник

7.16 – std::cin и обработка недопустимого ввода

При написании программ вы всегда должны учитывать, как пользователи (непреднамеренно или наоборот) будут использовать ваши программы некорректно. Хорошо написанная программа будет предвидеть, как пользователи будут использовать ее неправильно, и либо аккуратно обработает эти случаи, либо вообще предотвратит их появление (если это возможно). Программа, которая хорошо обрабатывает случаи ошибок, называется надежной.

Чтобы обсудить, как std::cin и operator>> могут давать сбой, сначала полезно немного узнать, как они работают.

Когда мы используем operator>> для получения пользовательского ввода и помещения его в переменную, это называется «извлечением». Соответственно, в этом контексте оператор >> называется оператором извлечения.

При использовании оператора извлечения происходит следующая процедура:

Извлечение завершается успешно, если из входного буфера извлечен хотя бы один символ. Любые неизвлеченные входные данные остаются во входном буфере для дальнейшего извлечения. Например:

Извлечение не выполняется, если входные данные не соответствуют типу переменной, в которую они извлекаются. Например:

Проверка ввода

Процесс проверки того, соответствуют ли пользовательские входные данные тому, что ожидает программа, называется проверкой ввода.

Есть три основных способа проверки ввода:

Поскольку строки не имеют никаких ограничений на ввод символов, извлечение гарантированно завершится успешно (хотя помните, что std::cin прекращает извлечение на первом неведущем пробельном символе). После того, как строка введена, программа может проанализировать эту строку, чтобы узнать, корректна она или нет. Однако анализ строк и преобразование вводимых строк в другие типы (например, числа) может быть сложной задачей, поэтому это делается только в редких случаях.

Чаще всего мы позволяем std::cin и оператору извлечения выполнять эту тяжелую работу. В этом методе мы позволяем пользователю вводить всё, что он хочет, заставляем std::cin и operator>> попытаться извлечь данные и справиться с последствиями, если это не удастся. Это самый простой способ, о котором мы поговорим ниже.

Пример программы

Рассмотрим следующую программу-калькулятор, в которой нет обработки ошибок:

Эта простая программа просит пользователя ввести два числа и математический оператор.

Теперь подумайте, где неверный ввод пользователя может нарушить работу этой программы.

Сначала мы просим пользователя ввести несколько чисел. Что, если он введет что-то, отличающееся от числа (например, ‘q’ )? В этом случае извлечение не удастся.

Во-вторых, мы просим пользователя ввести один из четырех возможных символов. Что, если он введет символ, отличный от ожидаемых? Мы сможем извлечь входные данные, но пока не обрабатываем то, что происходит после.

Типы недопустимых входных текстовых данных

Обычно мы можем разделить ошибки ввода текста на четыре типа:

Таким образом, чтобы сделать наши программы устойчивыми, всякий раз, когда мы запрашиваем у пользователя ввод, мы в идеале должны определить, может ли произойти каждый из вышеперечисленных возможных вариантов, и если да, написать код для обработки этих случаев.

Случай ошибки 1: извлечение успешно, но входные данные не имеют смысла

Это самый простой случай. Рассмотрим следующий вариант выполнения приведенной выше программы:

Решение здесь простое: выполните проверку ввода. Обычно она состоит из 3 шагов:

Как видите, мы используем цикл while для бесконечного цикла до тех пор, пока пользователь не предоставит допустимые данные. Если он этого не делает, мы просим его повторить попытку, пока он не даст нам правильные данные, не закроет программу или не уничтожит свой компьютер.

Случай ошибки 2: извлечение успешно, но с посторонними входными данными

Рассмотрим следующий вариант выполнения приведенной выше программы:

Как думаете, что будет дальше?

Программа выводит правильный ответ, но форматирование испорчено. Давайте подробнее разберемся, почему.

Хотя программа работает, выполнение запутано. Было бы лучше, если бы любые введенные посторонние символы просто игнорировались. К счастью, символы игнорировать легко:

Теперь наша программа будет работать, как ожидалось, даже если мы введем «5*7» при первом запросе ввода – 5 будет извлечено, а остальные символы из входного буфера будут удалены. Поскольку входной буфер теперь пуст, при следующем выполнении операции извлечения данные у пользователя будут запрашиваться правильно!

Случай ошибки 3: сбой при извлечении

Теперь рассмотрим следующий вариант выполнения нашей программы калькулятора:

Неудивительно, что программа работает не так, как ожидалось, но интересно, как она дает сбой:

и программа внезапно завершается.

Это очень похоже на случай ввода посторонних символов, но немного отличается. Давайте посмотрим подробнее.

Находясь в «режиме отказа», будущие запросы на извлечение входных данных будут автоматически завершаться ошибкой. Таким образом, в нашей программе калькулятора вывод запросов всё еще печатается, но любые запросы на дальнейшее извлечение игнорируются. Программа просто выполняется до конца, а затем завершается (без вывода результата потому, что мы не прочитали допустимую математическую операцию).

К счастью, мы можем определить, завершилось ли извлечение сбоем, и исправить это:

Давайте, интегрируем это в нашу функцию getDouble() :

Примечание. До C++11 неудачное извлечение не приводило к изменению извлекаемой переменной. Это означает, что если переменная была неинициализирована, она останется неинициализированной в случае неудачного извлечения. Однако, начиная с C++11, неудачное извлечение из-за недопустимого ввода приведет к тому, что переменная будет инициализирована нулем. Инициализация нулем означает, что для переменной установлено значение 0, 0.0, «» или любое другое значение, в которое 0 преобразуется для этого типа.

Случай ошибки 4: извлечение успешно, но пользователь выходит за пределы значения числа

Рассмотрим следующий простой пример:

Что произойдет, если пользователь введет слишком большое число (например, 40000)?

В приведенном выше случае std::cin немедленно переходит в «режим отказа», но также присваивает переменной ближайшее значение в диапазоне. Следовательно, x остается с присвоенным значением 32767. Дополнительные входные данные пропускаются, оставляя y с инициализированным значением 0. Мы можем обрабатывать этот вид ошибки так же, как и неудачное извлечение.

Примечание. До C++11 неудачное извлечение не приводило к изменению извлекаемой переменной. Это означает, что если переменная была неинициализирована, в случае неудачного извлечения она останется неинициализированной. Однако, начиная с C++11, неудачное извлечение вне диапазона приведет к тому, что переменной будет присвоено ближайшее значение в диапазоне.

Собираем всё вместе

Вот наш пример калькулятора с полной проверкой ошибок:

Заключение

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

Вы можете использовать операторы if и булеву логику, чтобы проверить, являются ли входные данные ожидаемыми и осмысленными.

Следующий код очистит любые посторонние входные данные:

Следующий код будет проверять и исправлять неудачные извлечения или переполнение:

Наконец, используйте циклы, чтобы попросить пользователя повторно ввести данные, если исходные входные данные были недопустимыми.

Примечание автора

Проверка ввода важна и полезна, но она также делает примеры более сложными и трудными для понимания. Соответственно, на будущих уроках мы, как правило, не будем проводить никакой проверки вводимых данных, если они не имеют отношения к чему-то, чему мы пытаемся научить.

Источник

1.5 – Знакомство с iostream: cout, cin и endl

Библиотека ввода/вывода

Библиотека ввода/вывода (библиотека io) является частью стандартной библиотеки C++, которая имеет дело с базовым вводом и выводом. Мы будем использовать функции этой библиотеки для получения ввода с клавиатуры и вывода данных в консоль. Буквы io в iostream означают «input/output» (ввод/вывод).

std::cout

Вспомним нашу программу Hello world :

std::cout может печатать не только текст, но и числа:

Это дает результат:

Его также можно использовать для вывода значений переменных:

Это дает результат:

Чтобы напечатать несколько элементов в одной строке, для объединения (связывания) нескольких частей выводимых данных, оператор вставки ( ) можно использовать несколько раз в одном выражении. Например:

Эта программа печатает:

Вот еще один пример, в котором мы печатаем и текст, и значение переменной в одном выражении:

Эта программа печатает:

std::endl

Как вы думаете, что напечатает следующая программа?

Результат может вас удивить:

Отдельные выражения вывода не приводят к отдельным выводимым строкам в консоли.

Если мы хотим выводить в консоль отдельные выводимые строки, нам нужно указать консоли, когда необходимо переместить курсор на следующую строку.

Совет

В приведенной выше программе второй std::endl технически не нужен, так как программа сразу же после этого завершается. Однако он служит двум полезным целям: во-первых, он помогает указать, что строка вывода является «законченной мыслью». Во-вторых, если мы позже захотим добавить дополнительные выражения вывода, нам не нужно будет изменять существующий код. Мы можем просто добавить новые выражения.

std::endl против ‘\n’

Вот пример, в котором ‘\n’ используется двумя разными способами:

Этот код напечатает:

Обратите внимание, что когда ‘\n’ используется сам по себе для перемещения курсора на следующую строку, необходимы одинарные кавычки. При встраивании в текст, который уже заключен в двойные кавычки, одинарные кавычки не нужны.

Мы рассмотрим, что такое ‘\n’ более подробно, когда перейдем к уроку о символах (4.11 – Символы).

Лучшая практика

Предупреждение

‘\n’ использует обратный слеш (как и все специальные символы в C++), а не прямой слеш. Использование прямого слеша (например, ‘/n’ ) может привести к неожиданному поведению.

std::cin

Если ваш экран закрывается сразу после ввода числа, обратитесь к уроку «0.8 – Несколько основных проблем C++» для решения этой проблем.

Лучшая практика

Существуют споры о том, нужно ли инициализировать переменную непосредственно перед тем, как передать ей значение, предоставленное пользователем, через другой источник (например, std::cin ), поскольку значение, предоставленное пользователем, просто перезапишет значение инициализации. В соответствии с нашей предыдущей рекомендацией о том, что переменные всегда следует инициализировать, лучше всего сначала инициализировать переменную.

Мы обсудим, как std::cin обрабатывает недопустимые входные данные в следующем уроке (7.16 – std::cin и обработка недопустимых входных данных).

Для продвинутых читателей

Резюме

Подробнее об операторах мы поговорим в уроке «1.9 – Знакомство с литералами и операторами».

Небольшой тест

Вопрос 1

Рассмотрим следующую программу, которую мы использовали выше:

Запустите эту программу несколько раз и опишите, что произойдет, если вместо этого вы введете следующие типы входных данных:

б) Число с дробной частью. Попробуйте числа с дробными составляющими меньше 0,5 и больше 0,5 (например, 3,2 и 3,7).

Дробная составляющая опущена.

Всё прекрасно работает.

г) Слово, например «Hello».

д) Действительно большое число (минимум 3 миллиарда).

Вы получаете, казалось бы, случайное число.

Последнее предложение может быть особенно неожиданным. Попробуйте! Это происходит потому, что x может содержать числа только до определенного размера. После этого он «переполняется». Мы обсудим переполнение в следующем уроке.

Источник

Русские Блоги

cin.clear () и связанное с ним использование

1. cin.clear（）

Используется для изменения индикатора состояния cin.

cin.sync () используется для очистки потока данных в области кэша.
Если идентификатор не изменился, его нельзя ввести, даже если поток данных очищен. Таким образом, эти два должны использоваться вместе.

Мы определяем переменную, которая будет введена как целое число, но если мы введем английские буквы или китайские символы, произойдет ошибка. В cin есть метод для обнаружения этой ошибки, который называется cin.rdstate (); когда cin.rdstate () При возврате 0 (то есть ios :: goodbit) ошибки нет, и вы можете продолжить ввод или работу. Если вы вернете 4, произойдет нефатальная ошибка, то есть ios :: failbit, вы не сможете продолжать вводить или работать. И cin.clear может контролировать нас. Идентификация этой проблемы в cin. Язык следующий: cin.clear (идентификатор); идентификационный символ:

Goodbit без ошибок
Eofbit достиг конца файла
нефитальная ошибка ввода / вывода при сбое, исправимая
badbit Фатальная ошибка ввода / вывода, не может быть исправлена. Если она находится в классе ввода / вывода, вам необходимо добавить ios :: identifier
С помощью cin.clear мы можем подтвердить его внутренний идентификатор и повторно ввести его, если он введен неправильно. В сочетании с методом реального очищения потока данных cin.sync () см. следующий пример:

2. cin.ignore()

Метод cin.ignore (a, ch) предназначен для извлечения символов из входного потока (cin). Извлеченные символы игнорируются и не используются. Каждый раз, когда символ отбрасывается, он подсчитывает и сравнивает символы: если число достигает a или символ, который отбрасывается, является ch, выполнение функции cin.ignore () прекращается, в противном случае он продолжает ждать. Обычной функцией является очистка содержимого буфера ввода, заканчивающегося возвратом каретки, что исключает влияние предыдущего ввода на следующий ввод. Например, это может быть использовано: cin.ignore (1024, ‘\ n’), обычно первый параметр устанавливается достаточно большим, так что на самом деле всегда работает только второй параметр ‘\ n’, так что это предложение ставится Все символы перед возвратом каретки (включая возврат каретки) удаляются из входного буфера (потока).

Если вы введете bcdabcd в адрес, то в это время в потоке останется bcd \ n, а cin.ignore (), в это время съедено b, что оставит оставшийся cd \ n в потоке непосредственно в cin.getline ( str3,30); должен быть символ \ n, поэтому getline возвращается прямо сюда.

3 Сравнение cin.sync () и cin.ignor ()

Но поскольку программа не всегда знает ход выполнения внешнего ввода во время выполнения программы, трудно контролировать, очищено ли содержимое буфера ввода. Часто мы можем просто отказаться от части, а не от всего входного буфера. Например, очистка текущей строки или очистка символов новой строки в конце строки. Но если в буфере уже есть следующая строка, эта часть может быть тем, что мы хотим сохранить. В настоящее время лучше не использовать sync (). Попробуйте вместо этого использовать функцию игнорирования.
cin.ignore (numeric_limits :: max (), ’/ n’); // очистить текущую строку
cin.ignore (numeric_limits :: max ()); // Очистить все в cin

Использование ignore, очевидно, более точно контролирует буфер, чем sync ().

Источник

Std cin c что это

Хочу продолжить тему скорости ввода/вывода в C++, которую когда-то начал товарищ freopen. freopen сравнивал производительность двух способов ввода/вывода в C++: унаследованной от C библиотеки stdio ( ) и более новой библиотеки iostreams ( /…). Однако в этих тестах не было учтено, что iostreams можно значительно ускорить, включив некоторые оптимизации. Об их существовании уже неоднократно упоминалось на Codeforces (раз, два, три). Сейчас я написал софт, который сравнивает производительность stdio и iostreams на стандартном вводе/выводе с учётом этого.

Что это за оптимизации?

Первая состоит в том, что в начале программы, перед каким-либо вводом/выводом, можно вставить строчку

Эта команда отключает синхронизацию iostreams с stdio (описание). По умолчанию она включена, то есть, iostreams и stdio можно использовать вместе на одном и том же потоке, перемежая их вызовы. После отключения синхронизации так делать больше нельзя, однако за счёт этого iostreams может работать быстрее.

Вторая оптимизация заключается в том, что для cin можно выключить привязку к cout :

Какие тесты включены в программу?

Я постарался сымитировать наиболее типичные ситуации, возникающие при решении задач.

Какие тесты не включены в программу?

Как это запустить у себя?

Дополнительные замечания

Чтобы все запуски были в равных условиях. Хотя, это несколько спорный вопрос. Может, лучше не удалять, а переписывать?

Чтобы исключить время запуска/завершения процесса.

Это можно. Но сначала мне надо понять, как это делать в Windows 🙂

Результаты

Запускал на компьютере с Pentium 4, так что время может показаться несколько большим.

Какие делать выводы и что использовать, пусть каждый решает сам. В комментариях приветствуется флейм конструктивное обсуждение.

Дополнение

(описание). Это сработает только при выполнении следующих дополнительных условий:

С этой оптимизацией посимвольный ввод/вывод ускоряется в восемь-девять (!) раз, а вместе с ним и вручную написанные функции ввода/вывода int :

В MinGW такое поведение включено по умолчанию и не имеет вышеописанных ограничений.

Источник