Функция Scanf C: описание. Изучение и использование функций printf() и scanf()
В данной статье функция scanf() рассматривается в общем виде без привязки к конкретному стандарту, поэтому сюда включены данные из любых стандартов C99, C11, C++11, C++14. Возможно, в некоторых стандартах функция работает с отличиями от изложенного в статье материала.
Функция scanf C - описание
scanf() - это функция, расположенная в заголовочном файле stdio.h(C) и cstdio(C++), она также называется форматированным вводом данных в программу. scanf читает символы из стандартного потока ввода (stdin) и преобразует их в соответствии с форматом, после чего записывает в указанные переменные. Формат - означает, что данные при поступлении приводятся к определенному виду. Таким образом, функция scanf C описывается:
scanf("%формат", &переменная1[, &переменная2,[…]]),
где переменные передаются в виде адресов. Причина такого способа передачи переменных в функцию очевидна: в результате работы она возвращает значение, указывающее на наличие ошибок, поэтому единственным способом изменять значения переменных является передача по адресу. Также, благодаря такому способу, функция может обрабатывать данные любых типов.
Некоторые программисты из-за аналогии с другими языками называют функции, подобные scanf() или printf(), процедурами.
Scanf позволяет осуществлять ввод всех базовых типов языка: char, int, float, string и т.д. В случае с переменными типа string нет нужды указывать знак адреса - «&», так как переменная типа string является массивом, и имя ее является адресом первого элемента массива в памяти компьютера.
Формат ввода данных или управляющая строка
Начнем с рассмотрения примера использования функции scanf C из описания.
#include
Формат ввода состоит из следующих четырех параметров: %[*][ширина][модификаторы] тип. При этом знак «%» и тип являются обязательными параметрами. То есть, минимальный вид формата выглядит следующим образом: “%s”, “%d” и так далее.
В общем случае символы, составляющие строку формата, делятся на:
- спецификаторы формата - все, что начитается с символа %;
- разделительные или пробельные символы - ими считаются пробел, табуляция(\t), новая строка (\n);
- символы, отличающиеся от пробельных.
Функция может оказаться небезопасной.
Используйте вместо scanf() функцию scanf_s().
(сообщение от Visual Studio)
Тип, или спецификаторы формата, или литеры преобразования, или контролирующие символы
Описание scanf C обязано содержать, как минимум, спецификатор формата, который указывается в конце выражений, начинающихся со знака «%». Он сообщает программе тип данных, который следует ожидать при вводе, обычно с клавиатуры. Список всех спецификаторов формата в таблице ниже.
| Значение |
||
| Программа ожидает ввод символа. Переменная для записи должна иметь символьный тип char. |
||
| Программа ожидает ввод десятичного числа целого типа. Переменная должна иметь тип int. |
||
| Программа ожидает ввод числа с плавающей точкой (запятой) в экспоненциальной форме. Переменная должна иметь тип float. |
||
| Программа ожидает ввод числа с плавающей точкой (запятой). Переменная должна иметь тип float. |
||
| 7 | Программа ожидает ввод числа с плавающей точкой (запятой). Переменная должна иметь тип float. |
|
| Программа ожидает ввод восьмеричного числа. Переменная должна иметь тип int. |
||
| Программа ожидает ввод строки. Строкой считается набор любых символов до первого встреченного разделительного символа. Переменная должна иметь тип string. |
||
| Программа ожидает ввод шестнадцатеричного числа. Переменная должна иметь тип int. |
||
| Переменная ожидает ввод указателя. Переменная должна иметь тип указателя. |
||
| Записывает в переменную целое значение, равное количеству считанных до текущего момента символов функцией scanf. |
||
| Программа считывает беззнаковое целое число. Тип переменной должен быть unsigned integer. |
||
| Программа ожидает ввод двоичного числа. Переменная должна иметь тип int. |
||
| Набор сканируемых символов. Программа ожидает ввод символов, из ограниченного пула, указанного между scanf будет работать до тех пор, пока на потоке ввода находятся символы из указанного множества. |
||
Символы в строке формата
Символ звездочка (*)
Звездочка (*) - это флаг, указывающий, что операцию присвоения надо подавить. Звездочка ставится сразу после знака «%». Например,
Scanf("%d%*c%d", &x, &y); //игнорировать символ между двумя целыми числами. scanf("%s%*d%s", str, str2); //игнорировать целое число, между двумя строками.
То есть, если ввести в консоли строку «45-20» программа сделает следующее:
- Переменной «x» будет присвоено значение 45.
- Переменной «y» будет присвоено значение 20.
- А знак минус(тире) «-» будет проигнорирован благодаря «%*c».
Ширина (или ширина поля)
Это целое число между знаком «%» и спецификатором формата, которое определяет максимальное количество символов для считывания за текущую операцию чтения.
Следует иметь в виду несколько важных моментов:
- scanf прекратит свою работу, если встретит разделительный символ, даже если не считал 20 символов.
- Если на ввод подается больше 20 символов, в переменную str будут записаны только первые 20 из них.
Модификаторы типа (или точность)
Это специальные флаги, которые модифицируют тип данных, ожидаемых к вводу. Флаг указывается слева от спецификатора типа:
- L или l (маленькая L) При использовании «l» со спецификаторами d, i, o, u, x, флаг сообщает программе, что ожидается ввод данных типа long int. При использовании «l» со спецификатором e или f, флаг сообщает программе, что она должна ожидать ввод значения типа double. Использование «L» сообщает программе, что ожидается значение типа long double. Использование «l» со спецификаторами «c» и «s» сообщает программе, что ожидаются двухбайтовые символы типа wchar_t. Например, "%lc", "%ls", "%l".
- h - флаг, указывающий на тип short.
- hh - обозначает, что переменная является указателем на значение типа signed char или unsigned char. Флаг можно использовать со спецификаторами d, i, o, u, x, n.
- ll (две маленькие L) - обозначает, что переменная является указателем на значение типа signed int или unsigned long long int. Флаг используется со спецификаторами: d, i, o, u, x, n.
- j - обозначает, что переменная является указателем на тип intmax_t или uintmax_t из заголовочного файла stdint.h. Используется со спецификаторами: d, i, o, u, x, n.
- z - обозначает, что переменная является указателем на тип size_t, определение которого находится в stddef.h. Используется со спецификаторами: d, i, o, u, x, n.
- t - обозначает, что переменная является указателем на тип ptrdiff_t. Определение на этот тип находится в stddef.h. Используется со спецификаторами: d, i, o, u, x, n.
Более явно картину с модификаторами можно представить в виде таблицы. Такое описание scanf C для програмистов будет понятнее.
Остальные символы
Любые символы, которые будут встречены в формате, будут отбрасываться. При этом стоит отметить, что наличие в управляющей строке пробельных или разделительных символов (новая строка, пробел, табуляция) может приводить к разному поведению функции. В одной версии scanf() будет читать без сохранения любое количество разделителей до момента, пока не встретит символ, отличный от разделителя, а в другой версии - пробелы (только они) не играют роли и выражение "%d + %d" эквивалентно "%d+%d".
Примеры
Рассмотрим ряд примеров, позволяющих поразмыслить и точнее понять работу функции.
Scanf("%3s", str); //если ввести в консоли строку «1d2s3d1;3», в str запишется только «1d2» scanf("%dminus%d", &x, &y); //символы «minus» между двумя числами будут отброшены scanf("%5", str); //ввод символов в str будет происходить до тех пор, пока их не будет 5 и символы являются числами от 0 до 9. scanf("%lf", &d); //ожидается ввод данных типа double scanf("%hd", &x); //ожидается число типа short scanf("%hu", &y); //ожидается число типа unsigned short scanf("lx", &z); //ожидается число типа long int
Из приведенных примеров видно, как меняется ожидаемое число с использованием различных символов.
scanf C - описание для начинающих
Данный раздел будет полезен новичкам. Зачастую нужно иметь под рукой не столько полное описание scanf C, сколько детали работы функции.
- Функция является отчасти устаревшей. Существует несколько разных реализаций в библиотеках различных версий. Например, усовершенствованная функция scanf S C, описание которой можно найти на сайте microsoft.
- Количество спецификаторов в формате должно соответствовать количеству переданных функции аргументов.
- Элементы входного потока должны отделяться только разделительными символами: пробел, табуляция, новая строка. Запятая, точка с запятой, точка и т. д. - эти символы не являются разделительными для функции scanf().
- Если scanf встретит разделительный символ, ввод будет остановлен. Если переменных для чтения больше одной, то scanf перейдет к чтению следующей переменной.
- Малейшее несоответствие формата вводимых данных приводит к непредсказуемым результатам работы программы. Хорошо, если программа просто завершится с ошибкой. Но нередко программа продолжает работать и делает это неверно.
- scanf("%20s …", …); Если входной поток превышает 20 символов, то scanf прочитает первые 20 символов и, либо прекратит работу, либо перейдет к чтению следующей переменной, если она указана. При этом следующий вызов scanf продолжит чтение входного потока с того места, где остановилась работа предыдущего вызова scanf. Если при чтении первых 20 символов будет встречен разделительный символ, scanf прекратит свою работу или перейдет к чтению следующей переменной, даже если не считал 20 символов для первой переменной. При этом все несчитанные символы прицепятся к следующей переменной.
- Если набор сканируемых символов начать со знака «^», то scanf будет читать данные до тех пор, пока не встретит разделительный символ или символ из набора. Например, "%[^A-E1-5]" будет считывать данные из потока, пока не будет встречен один из символов английского алфавита от А до Е в верхнем регистре или одно из чисел от 1 до 5.
- Функция scanf C по описанию возвращает число, равное успешному количеству записей в переменные. Если scanf записывает 3 переменные, то результатом успешной работы функции будет возврат числа 3. Если scanf не смог записать ни одной переменной, то результат будет 0. И, наконец, если scanf вообще не смог начать работать по каким-либо причинам, результатом будет EOF.
- Если функция scanf() завершила свою работу некорректно. Например, scanf("%d", &x) - ожидалось число, а на ввод пришли символы. Следующий вызов scanf() начнет свою работу с того места в потоке ввода, где завершился предыдущий вызов функции. Чтобы преодолеть эту проблему, необходимо избавиться от проблемных символов. Это можно сделать, например, вызвав scanf("%*s"). То есть, функция прочитает строку символов и выбросит ее. Таким хитрым образом можно продолжить ввод нужных данных.
- В некоторых реализациях scanf() в наборе сканируемых символов недопустимо использование «-».
- Спецификатор “%c” читает каждый символ из потока. То есть символ -разделитель он также читает. Чтобы пропустить символ разделитель и продолжить читать нужный символ, можно использовать “%1s”.
- При использовании спецификатора «c» допустимо использовать ширину “%10c”, однако тогда в виде переменной функции scanf нужно передать массив элементов типа char.
- “%” - это значит "все маленькие буквы английского алфавита", а “%” - значит просто 3 символа: ‘z’, ‘a’, ‘-’. Иными словами, символ «-» означает диапазон только в том случае, если стоит между двумя символами, которые находятся в правильном порядке следования. Если «-» находится в конце выражения, в начале или в неверном порядке символов по обеим сторонам от них, то он представляет собой просто символ дефиса, а не диапазон.
Заключение
На этом завершается описание scanf C. Это хорошая удобная функция для работы в небольших программах и при использовании процедурного метода программирования. Однако главным недостатком является количество непредсказуемых ошибок, которые могут возникнуть при использовании scanf. Поэтому, описание scanf C при програмировании лучше всего держать перед глазами. В крупных профессиональных проектах используются потоки iostream, ввиду того, что обладают более высокоуровневыми возможностями, лучше позволяют отлавливать и обрабатывать ошибки, а также работать со значительными объемами информации. Также следует отметить, описание scanf C на русском доступно на сетевых многих источниках, как и примеры ее использования, ввиду возраста функции. Поэтому при необходимости всегда можно найти ответ на тематических форумах.
Как хорошо когда все данные даны, и ничего вводить не надо. Но, поверьте мне, так практически не бывает. Вспомните школу, когда вы измеряли определенные вещи, а потом полученные значения вставляли в нужные формулы.
scanf
В языке Си кроме функции вывода printf, существует так же функция scanf для ввода. Вот функцию scanf мы щас и рассмотрим подробнее:
int i;
scanf("%d", &i);
Вроде очень похоже на функцию printf. Так же есть в двойных кавычках спецификатор формата , но разница как раз находится во второй части функции. Обратили внимание на появление знака (&)? Так вот этот знак означает взятие адреса. Щас объясню для чего это нужно.
Мы должны записывать введенное значение не куда-то там, а именно по адресу, по которому находится наша переменная. Т.е. без знака (&) наше введенное значение попадет во все места, кроме того что нам нужно. Поэтому всегда, когда вам нужно вводить значения с клавиатуры, ставьте перед переменной знак взятия адреса (&).
Спецификаторы формата
Ну теперь пробежимся по спецификаторам формата :- %d - прочитать целое число
- %o - прочитать восьмеричное число
- %x - прочитать шестнадцатеричное число
- %e(%f) - прочитать вещественное число
- %с - прочитать символ
- %s - прочитать строку
int i;
scanf ("%d", &i);
int i;
scanf ("%o", &i);
int i;
scanf ("%x", &i);
float t;
scanf ("%f", &t);
char ch;
scanf ("%c", &ch);
char *str;;
scanf ("%s", str);
Пока не вникайте в работу со строками. Почему нету знака взятия адреса? Эту тему мы рассмотрим чуть позднее.
Операции сравнения
В компьютер изначально заложена булева логика, т.е. все построено на 0 и 1. Если не понимаете о чем речь, то пересмотрите фильм Матрица, где каждая зеленая заставка как раз состояла из этих двух магических цифр.
Конечно, 0 и 1 это хорошо, но нам нужен логический смысл, поэтому в логических операциях 0 - это FALSE, а 1 - это TRUE. Эти понятия TRUE и FALSE тесно связанны с операциями сравнения . Для начала приведем всевозможные операции сравнения:
В принципе, самая распространенная ошибка, которую делают новички - это путают операцию присваивания (=) с операцией сравнения (==). Это абсолютно разные вещи. Но у всех на первых порах кодирования возникают ошибки именно на этой почве, поэтому будьте внимательнее.
Функция scanf() является процедурой ввода общего назначения, считывающей данные из потока stdin. Она может считывать данные всех базовых типов и автоматически конвертировать их в нужный внутренний формат. Если бы printf() выполняла ввод, а не вывод, ее можно было бы назвать аналогом scanf().
Управляющая строка, на которую указывает format, состоит из символов трех типов:
- Спецификаторы формата
- Специальные символы
- Прочие символы (не специальные)
Спецификаторы формата следуют за символом процент и сообщают scanf(), данные какого типа будут считаны следующими. Коды спецификаторов приведены в таблице.
| Код | Значение |
|---|---|
| %с | Считать один символ |
| %d | |
| %i | Считать десятичное число целого типа |
| %е | |
| %f | Считать число с плавающей запятой |
| %g | Считать число с плавающей запятой |
| %о | Считать восьмеричное число |
| %s | Считать строку |
| %х | Считать шестнадцатиричное число |
| %р | Считать указатель |
| %n | Принимает целое значение, равное количеству считанных до текущего момента символов |
| %u | Считывает беззнаковое целое |
| % | Просматривает набор символов |
| %% | Считывает символ % |
Например, %s считывает строку, a %d считывает переменную целого типа.
Строка формата считывается слева направо, при этом устанавливается соответствие между кодами формата и аргументами из списка аргументов.
Специальные символы в управляющей строке заставляют scanf() пропускать один или больше специальных символов во входном потоке. Специальные символы - это пробел, табуляция или новая строка. Один специальный символ в управляющей строке заставляет scanf() считывать, не запоминая, любое количество (включая нуль) идущих подряд специальных символов из входного потока, пока не встретится символ, не являющийся специальным символом.
Наличие обычного символа заставляет scanf() считать и отбросить соответствующий символ. Например, "%d,%d" заставляет scanf() считать целое число, считать и отбросить запятую и затем считать еще одно целое число. Если указанный символ не обнаружен во входном потоке, scanf() останавливается.
Все переменные, используемые для приема значений с помощью функции scanf(), должны отыскиваться по их адресам. Это значит, что все аргументы функции должны быть указателями на переменные. Таким образом, С создает возможность передачи по ссылке, и это позволяет функции изменять содержимое аргумента.
Scanf("%d", &count);
Строки считываются в массивы символов, и имя массива, без всякого указателя, является адресом первого элемента массива. Поэтому, чтобы считать строку в массив символов address, можно использовать команду
Scanf("%s", address);
В этом случае имя address уже является указателем и не нуждается в префиксе &.
Элементы вводимых данных должны разделяться пробелами, знаками табуляции или новой строки.
Знаки пунктуации, такие как запятая, точка с запятой и т.п., не считаются разделителями. Это значит, что для оператора
Scanf("%d%d", &r, &с);
Последовательность 10 20 будет воспринята, а последовательность 10,20 - нет. Спецификаторы формата scanf() расположены в том же порядке, что и переменные в списке аргументов, которым присваиваются значения принимаемых переменных.
Знак *, помещенный после % и перед спецификатором формата, считывает данные указанного типа, но подавляет их присваивание. Таким образом, код
Scanf ("%d%*c%d", &х, &у);
При вводе последовательности 10/20 присваивает значение 10 переменной х, отбрасывает символ / и присваивает значение 20 переменной у.
Командами форматирования может задаваться модификатор максимальной ширины поля. Он представляет собой целое число, которое помещается между знаком % и спецификатором формата. Он ограничивает количество считываемых символов для любого поля. Например, если необходимо считать не больше, чем 20 символов в массив address, следует написать
Scanf ("%20s", address);
Если входной поток содержал больше 20 символов, то при последующем вызове функция ввода начнет ввод с того места, где был остановлен ввод при текущем обращении. Ввод поля может быть прерван и до достижения максимальной длины поля, если встретится пробел. В этом случае scanf() переходит к следующему полю.
Хотя пробелы, символы табуляции и новых строк используются как разделители полей, они считываются как любой другой символ при вводе одиночного символа. Например, при входном потоке х у функция
Scanf("%с%с%с", &а, &b, &с);
Поместит символ х в переменную а, пробел - в переменную b и y - в переменную c.
Надо быть внимательным: любые другие символы в управляющей строке - включая пробелы, символы табуляции и новых строк - используются для указания и отбрасывания символов из входного потока. Например, при входном потоке 10t20 функция
Scanf ("%st%s", &х, &у);
Поместит 10 в х, а 20 в у. Символ t будет отброшен, поскольку в управляющей строке имеется t.
Еще одна возможность функции scanf() называется множеством сканирования. С помощью множества сканирования определяются символы, которые будут считываться функцией scanf() и присваиваться элементам соответствующего массива символов. Чтобы задать множество сканирования, надо символы, ввод которых допустим, поместить в квадратные скобки. Перед первой квадратной скобкой ставится знак процента. Например, следующий перечень множества сканирования задает считывание функцией scanf() только символов А, В и С:
Соответствующий перечню множества сканирования аргумент должен быть указателем на массив символов. При использовании множества сканирования функция scanf() считывает символы и помещает их в указанный массив до тех пор, пока не встретится символ, не входящий в множество сканирования (то есть считываются только символы, входящие в множество сканирования).
Массив, возвращенный scanf(), будет содержать строку с нулевым символом в конце. Перечень считываемых символов можно задать и в инверсной форме. Для этого в качестве первого символа надо поместить ^. Тогда scanf() будет принимать любой символ, не входящий в множество сканирования.
С помощью кавычек можно задать диапазон воспринимаемых символов. Например, следующее выражение дает указание scanf() принимать буквы от «А» до «Z»:
Множество сканирования различает прописные и строчные буквы. Если необходимо, чтобы scanf() принимала те и другие, необходимо перечислить их в множестве сканирования отдельно.
Функция scanf() возвращает число, равное количеству полей, значения которых были действительно присвоены переменным. В это количество не входят поля, которые были считаны, но их значения не были ничему присвоены вследствие использования модификатора * для подавления присваивания. Если до присвоения значения первого поля произошла ошибка, возвращается EOF.
При использовании Borland С++ в 16-разрядной среде можно изменить модель памяти, используемую по умолчанию для компилирования программы, путем явного указания размера каждого указателя, используемого при вызове scanf(). Ближний указатель задается модификатором N, а дальний - модификатором F. (Нельзя использовать модификатор N, если программа скомпилирована для модели памяти huge.)
Основной задачей программирования является обработка информации, поэтому любой язык программирования имеет средства для ввода и вывода информации. В языке Си нет операторов ввода-вывода.
Ввод и вывод информации осуществляется через функции стандартной библиотеки. Прототипы рассматриваемых функций находятся в файле stdio.h . Эта библиотека содержит функции
- printf() — для вывода информации
- scanf() — для ввода информации.
Вывод информации
Функция printf()
предназначена для форматированного вывода. Она переводит данные в символьное представление и выводит полученные изображения символов на экран. При этом у программиста имеется возможность форматировать данные, то есть влиять на их представление
на экране.
Общая форма записи функции printf()
:
printf("СтрокаФорматов"
, объект1, объект2, ..., объектn);
СтрокаФорматов состоит из следующих элементов:
- управляющих символов;
- текста, представленного для непосредственного вывода;
- форматов, предназначенных для вывода значений переменных различных типов.
Объекты могут отсутствовать.
Управляющие символы не выводятся на экран, а управляют расположением выводимых символов. Отличительной чертой управляющего символа является наличие обратного слэша ‘\’ перед ним.
Основные управляющие символы:
- ‘\n’ - перевод строки;
- ‘\t’ - горизонтальная табуляция;
- ‘\v’ - вертикальная табуляция;
- ‘\b’ - возврат на символ;
- ‘\r’ - возврат на начало строки;
- ‘\a’ - звуковой сигнал.
Форматы нужны для того, чтобы указывать вид, в котором информация будет выведена на экран. Отличительной чертой формата является наличие символа процент ‘%’ перед ним:
- %d - целое число типа int со знаком в десятичной системе счисления;
- %u - целое число типа unsigned int ;
- %x - целое число типа int со знаком в шестнадцатеричной системе счисления;
- %o - целое число типа int со знаком в восьмеричной системе счисления;
- %hd - целое число типа short со знаком в десятичной системе счисления;
- %hu - целое число типа unsigned short ;
- %hx - целое число типа short со знаком в шестнадцатеричной системе счисления;
- %ld - целое число типа long int со знаком в десятичной системе счисления;
- %lu - целое число типа unsigned long int ;
- %lx - целое число типа long int со знаком в шестнадцатеричной системе счисления;
- %f - вещественный формат (числа с плавающей точкой типа float );
- %lf - вещественный формат двойной точности (числа с плавающей точкой типа double );
- %e - вещественный формат в экспоненциальной форме (числа с плавающей точкой типа float в экспоненциальной форме);
- %c - символьный формат;
- %s - строковый формат.
Строка форматов содержит форматы для вывода значений. Каждый формат вывода начинается с символа %
. После строки форматов через запятую указываются имена переменных, которые необходимо вывести.
Количество символов %
в строке формата должно совпадать с количеством переменных для вывода. Тип каждого формата должен совпадать с типом переменной, которая будет выводиться на это место. Замещение форматов вывода значениями переменных происходит в порядке их следования.
Пример на Си
1
2
3
4
5
6
7
8
9
10
#include
int
main()
{
int
a = 5;
float
x = 2.78;
printf("a=%d\n"
, a);
printf("x=%f\n"
, x);
getchar();
return
0;
}
Результат работы программы
Тот же самый код может быть представлен с использованием одного вызова printf
:
1
2
3
4
5
6
7
8
9
#include
int
main()
{
int
a = 5;
float
x = 2.78;
printf("a=%d\nx=%f\n"
, a, x);
getchar();
return
0;
}
Табличный вывод
При указании формата можно явным образом указать общее количество знакомест и количество знакомест, занимаемых дробной частью:
1
2
3
4
5
6
7
8
#include
int
main()
{
float
x = 1.2345;
printf("x=%10.5f\n"
, x);
getchar();
return
0;
}
Результат выполнения
В приведенном примере 10 - общее количество знакомест, отводимое под значение переменной; 5 - количество позиций после разделителя целой и дробной части (после десятичной точки). В указанном примере количество знакомест в выводимом числе меньше 10, поэтому свободные знакоместа слева от числа заполняются пробелами. Такой способ форматирования часто используется для построения таблиц.
Ввод информации
Функция форматированного ввода данных с клавиатуры scanf()
выполняет чтение данных, вводимых с клавиатуры, преобразует их во внутренний формат и передает вызывающей функции. При этом программист задает правила интерпретации входных данных с помощью спецификаций форматной строки.
Общая форма записи функции scanf()
:
scanf ("CтрокаФорматов"
, адрес1, адрес2,...);
Строка форматов аналогична функции printf()
.
Для формирования адреса переменной используется символ амперсанд ‘&’
:
адрес = &объект
Строка форматов и список аргументов для функции обязательны.
Пример на Си
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// для возможности использования scanf
#include
#include
int
main()
{
float
y;
system("chcp 1251"
); // переходим в консоли на русский язык
system("cls"
); // очищаем окно консоли
printf("Введите y: "
); // выводим сообщение
scanf("%f"
, &y); // вводим значения переменной y
printf("Значение переменной y=%f"
, y); // выводим значение переменной y
getchar(); getchar();
return
0;
}
Результат работы программы:
Функция scanf()
является функцией незащищенного ввода, т.к. появилась она в ранних версиях языка Си. Поэтому чтобы разрешить работу данной функции в современных компиляторах необходимо в начало программы добавить строчку
#define
_CRT_SECURE_NO_WARNINGS
Другой вариант — воспользоваться функцией защищенного ввода scanf_s()
, которая появилась несколько позже, но содержит тот же самый список параметров.
1
2
3
4
5
6
7
8
9
10
#include
int
main()
{
int
a;
printf("a = "
);
scanf_s("%d"
, &a);
printf("a = %d"
,a);
getchar(); getchar();
return
0;
}
Теги: Форматированный ввод, форматированный вывод, printf, scanf, fgets, getch, строка формата, спецификатор формата, флаги, управляющие символы.
Форматированный вывод
Сегодня мы рассмотрим две важные функции форматированного ввода и вывода. Устройство и работу этих функций полностью можно понять только после изучения работы с указателями и функций с переменным числом параметров. Но пользоваться этими функциями необходимо уже сейчас, так что некоторые моменты придётся пропустить.
Функция форматированного вывода printf получает в качестве аргументов строку формат и аргументы, которые необходимо вывести в соответствии с форматом, и возвращает число
выведенных символов. В случае ошибки возвращает отрицательное значение и устанавливает значение ferror. Если произошло несколько ошибок, errno равно EILSEQ.
int printf (const char * format, ...);
#include
Функция проходит по строке и заменяет первое вхождение % на первый аргумент, второе вхождение % на второй аргумент и т.д. Далее мы будем просто рассматривать список флагов и примеры использования.
Общий синтаксис спецификатора формата
%[флаги][ширина][.точность][длина]спецификатор
Спецификатор – это самый важный компонент. Он определяет тип переменной и способ её вывода.
| Спецификатор | Что хотим вывести | Пример |
|---|---|---|
| d или i | Целое со знаком в в десятичном виде | 392 |
| u | Целое без знака в десятичном виде | 7235 |
| o | Беззнаковое в восьмеричном виде | 657 |
| x | Беззнаковое целое в шестнадцатеричном виде | 7fa |
| X | Беззнаковое целое в шестнадцатеричном виде, верхний регистр | 7FA |
| f или F | Число с плавающей точкой | 3.4563745 |
| e | Экспоненциальная форма для числа с плавающей точкой | 3.1234e+3 |
| E | Экспоненциальная форма для числа с плавающей точкой, верхний регистр | 3.1234E+3 |
| g | Кратчайшее из представлений форматов f и e | 3.12 |
| G | Кратчайшее из представлений форматов F и E | 3.12 |
| a | Шестнадцатеричное представление числа с плавающей точкой | -0xc.90fep-2 |
| A | Шестнадцатеричное представление числа с плавающей точкой, верхний регистр | -0xc.90FEP-2 |
| c | Буква | a |
| s | Строка (нуль-терминированный массив букв) | Hello World |
| p | Адрес указателя | b8000000 |
| n | Ничего не пачатает. Аргументом должен быть указатель на signed int. По этому адресу будет сохранено количество букв, которое было выведено до встречи %n | |
| % | Два идущих друг за другом процента выводят знак процента | % |
#include
Строка формата также может включать в себя следующие необязательные суб-спецификаторы: флаг, ширина, .точность и модификатор (именно в таком порядке).
| .Точность | Описание |
|---|---|
| .число | Для спецификаторов целых (d, i, o, u, x, X) точность определяет минимальное количество знаков, которое необходимо вывести. Если значение короче,
то выводятся нули перед числом. Значение не обрезается, даже если оно длиннее. Точночть 0 означает, что для значения 0 ничего не выводится. Для спецификаторов чисел с плавающей точкой (a, A, e, E, f, F) это число знаков, которые необходимо вывести после десятичной точки (по умолчанию 6). Для g и G - это число значащих разрядов, которые необходимо вывести. Для s - выводится указанное число символов. По умолчанию выводятся все символы до первого нулевого. Если число не стоит, то по умолчанию точность равна 0 |
| .* | Точность не указана в строке формата, она передаётся отдельно в виде аргумента, который должен предшествовать выводимому числу |
#include
Суб-спецификатор длины изменяет длину типа. В случае, если длина не совпадает с типом, по возможности происходит преобразование до нужного типа.
| спецификаторы | |||||||
|---|---|---|---|---|---|---|---|
| Длина | d, i | u o x X | f F e E g G a A | c | s | p | n |
| (none) | int | unsigned int | double | int | char* | void* | int* |
| hh | signed char | unsigned char | signed char* | ||||
| h | short int | unsigned short int | short int* | ||||
| l | long int | unsigned long int | wint_t | wchar_t* | long int* | ||
| ll | long long int | unsigned long long int | long long int* | ||||
| j | intmax_t | uintmax_t | intmax_t* | ||||
| z | size_t | size_t | size_t* | ||||
| t | ptrdiff_t | ptrdiff_t | ptrdiff_t* | ||||
| L | long double | ||||||
#include
Форматированный ввод
Рассмотрим форматированный ввод функцией scanf.
int scanf(const char*, ...)
Функция принимает строку формата ввода (она похожа на строку формата printf) и адреса, по которым необходимо записать считанные данные. Возвращает
количество успешно проинициализированных аргументов.
Формат спецификатора ввода
%[*][ширина][длинна]спецификатор
| Спецификатор | Описание | Выбранные символы |
|---|---|---|
| i, u | Целые | Произвольное число цифр (0-9), возможно, начинающихся с + или -. Если число начинается с 0, то считывается в восьмеричном формате, если с 0x, то в шестнадцатеричном. |
| d | Десятичное целое | Произвольное число цифр (0-9), возможно, начинающихся с + или -. |
| o | восьмеричное целое | Произвольное число цифр (0-7), возможно, начинающихся с + или -. |
| x | Шестнадцатеричное целое | Произвольное число цифр (0-F), возможно, начинающихся с + или - и префикса 0x или 0X. |
| f, e, g | Число с плавающей точкой | Число, состоящее из набора цифр 0-9, возможно с десятичным разделителем (точкой). Возможно также представление в экспоненциальной форме. C99 позволяет также вводить число в шестнадцатеричном формате. |
| a | ||
| c | Символ | Если ширина не передана, то считывает один символ. Если ширина передана, то считывает нужное количество символов и размещает их в массиве БЕЗ терминального символа на конце. |
| s | Строка | Считывает все не пробельные символы. Если указана ширина, то не более n символов. Ставит на место n+1 символа терминальный. |
| p | Адрес указателя | Последовательность символов, трактуемая как адрес указателя. Формат зависит от реализации, но совпадает с тем, как выводит printf с ключом p |
| [символы] | Множество символов | Считывает только те символы, которые записаны в квадратных скобках, С99 |
| [^символы] | Множество символов | Считывает только те символы, которые не указаны в квадратных скобках, С99 |
| n | Ничего не считывает | Сохраняет число уже считанных символов по указанному адресу |
Как и в printf, ширина, заданная символом * ожидает аргумента, который будт задавать ширину. Флаг длина совпадает с таким флагом функции printf.
#include
Кроме функций scanf и printf есть ещё ряд функций, которые позволяют получать вводимые данные
int getch() - возвращает введённый символ, при этом не выводит его на консоль. #includechar * fgets (char * str, int num, FILE * stream) - функция позволяет считывать строку с пробельными символами. Несмотря на то, что она работает с файлом, можно с её помощью считывать и из стандартного потока ввода. Её преимущество относительно gets в том, что она позволяет указать максимальный размер считываемой строки и заканчивает строку терминальным символом.
#include
Это не полный набор различных функций символьного ввода и вывода. Таких функций море, но очень многие из них небезопасны, поэтому перед использованием внимательно читайте документацию.
