Функции printf() и scanf() дают нам возможность взаимодействовать с программой. Мы называем их функциями ввода-вывода. Это не единственные функции, которыми мы можем воспользоваться для ввода и вывода данных с помощью программ на языке Си, но они наиболее универсальны. Эти функции входят в описание языка Си и они даны в библиотеке stdio.h. Обычно функции printf() и scanf() работают во многом одинаково - каждая использует управляющую строку и список аргументов. Сначала мы рассмотрим работу функции printf(), затем scanf().

Формат	Тип выводимой информации
	десятичное целое число
	один символ
	строка символов
	экспоненциальная запись
	число с плавающей точкой, десятичная запись
	используется вместо записи %f или %e
	десятичное целое число без знака
	восьмеричное целое число без знака
	шестнадцатеричное целое число без знака

Инструкции, передаваемые функции printf(), когда мы хотим напечатать некоторую переменную, зависят от того, какого типа эта переменная. Например, при выводе на печать целого числа применяется формат %d, а при выводе символа - %c. Форматы перечислены в таблице.

Посмотрим теперь, как эти формы применяются:

/* печать */

#include

#define PI 3.14159

int number = 2003;

printf("Интернет-университет информационных технологий был открыт в %d году \n", number);

printf("Значение числа pi равно %f.\n", PI);

Формат, указываемый при обращении к функции printf(), выглядит следующим образом:

printf(Управляющая строка, аргумент1, аргумент2,_);

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

Управляющая строка - строка символов, показывающая, как должны быть напечатаны параметры. Например, в операторе

printf("%d студентов получили оценку %f.\n",

управляющей строкой служит фраза в кавычках, а number и z - аргументы или в данном случае значения двух переменных.

Мы видим, что в управляющей строке содержится информация двух различных типов:

Символы, печатаемые текстуально.

Идентификаторы данных, называемые также спецификациями преобразования .

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

printf("Эта книга не очень дорогая!\n");

printf("%c%d\n","$",cost);

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

Например:

printf("Только %d%% населения способно учиться самостоятельно! \n",i);

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

Только 5% населения способно учиться самостоятельно!

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

Модификаторы	Значение
	Аргумент будет печататься с левой позиции поля заданной ширины. Обычно печать аргумента оканчивается в самой правой позиции поля. Пример: %-10
строка цифр	Задает минимальную ширину поля. Большее поле будет использоваться, если печатаемое число или строка не помещается в исходном поле Пример: %4d
строка цифр	Определяет точность: для типов данных с плавающей точкой число печатаемых цифр справа от десятичной точки; для символьных строк - максимальное число печатаемых символов Пример: %4.2f(две десятичные цифры для поля шириной в четыре символа)
	Соответствующий элемент данных имеет тип long, а не int Пример: %ld

printf("/%d/\n",135);

printf("/%2d/\n",135);

printf("/%10d/\n",135);

printf("/%-10d/\n",135);

Первая спецификация преобразования %d не содержит модификаторов. Это так называемый выбор по умолчанию, т. е. результат действия компилятора в случае, если вы не дали ему никаких дополнительных инструкций. Вторая спецификация преобразования - %2d. Она указывает, что ширина поля должна равняться 2, но, поскольку число состоит из трех цифр, поле автоматически расширяется до необходимого размера. Следующая спецификация %10d показывает, что ширина поля равна 10. Последняя спецификация %-10d также указывает ширину поля, равную 10, а знак - приводит к сдвигу всего числа к левому краю.

Функция printf() позволяет выводить информацию на экран при программировании в консольном режиме. Данная функция определена в библиотеке stdio.h и имеет следующий синтаксис:

int printf(const char *format [, argument]...);

Здесь первый аргумент *format определяет строку, которая выводится на экран и может содержать специальные управляющие символы для вывода переменных. Затем, следует список необязательных аргументов, которые поясняются ниже. Функуция возвращает либо число отображенных символов, либо отрицательное число в случае своей некорректной работы.

В самой простой реализации функция printf() просто выводит заданную строку на экран монитора:

printf(“Привет мир.”);

Однако с ее помощью можно выводить переменные разного типа: начиная с числовых и заканчивая строковыми. Для выполнения этой операции используются специальные управляющие символы, которые называются спецификаторами и которые начинаются с символа %. Следующий пример демонстрирует вывод целочисленной переменной num на экран монитора с помощью функции printf():

int num;
num = 5;
printf(“%d”, num);

В первых двух строках данной программы задается переменная с именем num типа int. В третьей строке выполняется вывод переменной на экран. Работа функции printf() выглядит следующим образом. Сначала функция анализирует строку, которую необходимо вывести на экран. В данном случае это «%d». Если в этой строке встречается спецификатор, то на его место записывается значение переменной, которая является вторым аргументом функции printf(). В результате, вместо исходной строки «%d» на экране появится строка «5», т.е. будет выведено число 5.

Следует отметить, что спецификатор «%d» выводит только целочисленные типы переменных, например int. Для вывода других типов следует использовать другие спецификаторы. Ниже перечислены основные виды спецификаторов:

%с – одиночный символ
%d – десятичное целое число со знаком
%f – число с плавающей точкой (десятичное представление)
%s – строка символов (для строковых переменных)
%u – десятичное целое без знака
%% - печать знака процента

С помощью функции printf() можно выводить сразу несколько переменных. Для этого используется следующая конструкция:

int num_i;
float num_f;
num_i = 5;
num_f = 10.5;
printf(“num_i = %d, num_f = %f”, num_i, num_f);

Результат выполнения программы будет выглядеть так:

num_i = 5, num_f = 10.5

Кроме спецификаторов в функции printf() используются управляющие символы, такие как перевод строки \n, табуляции \t и др. Например, если в ранее рассмотренном примере необходимо вывести значения переменных не в строчку, а в столбик, то необходимо переписать функцию printf() следующим образом:

printf(“num_i = %d,\n num_f = %f”, num_i, num_f);

Аналогично используется и символ табуляции.

Для ввода информации с клавиатуры удобно использовать функцию scanf() библиотеки stdio.h, которая имеет следующий синтаксис:

int scanf(const char *format [,argument]...);

Здесь, как и для функции printf(), переменная *format определяет форматную строку для определения типа вводимых данных и может содержать те же спецификаторы что и функция printf(). Затем, следует список необязательных аргументов. Работа функции scanf() демонстрируется на листинге 1.4.

Листинг 1.4. Пример использования функции scanf().

#include
int main()
{
int age;
float weight;
printf(“Введите информацию о Вашем возрасте: ”);
scanf(“%d”, &age);
printf(“Введите информацию о Вашем весе: ”);
scanf(“%f”, &weigth);
printf(“Ваш возраст = %d, Ваш вес = %f”, age, weigth);

Return 0;
}

Основным отличием применения функции scanf() от функции printf() является знак & перед именем переменной, в которую записываются результаты ввода.

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

scanf(“ %d, %d ”, &n, &m);

Функция scanf() интерпретирует это так, как будто ожидает, что пользователь введет число, затем – запятую, а затем – второе число. Все происходит так, как будто требуется ввести два целых числа следующим образом:

Функция scanf() возвращает число успешно считанных элементов. Если операции считывания не происходило, что бывает в том случае, когда вместо ожидаемого цифрового значения вводится какая-либо буква, то возвращаемое значение равно 0.

В данной статье функция 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 int main() { int x; while (scanf("%d", &x) == 1) printf("%d\n", x); return 0; //требование linux-систем }

Формат ввода состоит из следующих четырех параметров: %[*][ширина][модификаторы] тип. При этом знак «%» и тип являются обязательными параметрами. То есть, минимальный вид формата выглядит следующим образом: “%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» программа сделает следующее:

1. Переменной «x» будет присвоено значение 45.
2. Переменной «y» будет присвоено значение 20.
3. А знак минус(тире) «-» будет проигнорирован благодаря «%*c».

Ширина (или ширина поля)

Это целое число между знаком «%» и спецификатором формата, которое определяет максимальное количество символов для считывания за текущую операцию чтения.

Следует иметь в виду несколько важных моментов:

1. scanf прекратит свою работу, если встретит разделительный символ, даже если не считал 20 символов.
2. Если на ввод подается больше 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() является процедурой ввода общего назначения, считывающей данные из пото­ка stdin. Она может считывать данные всех базовых типов и автоматически конвертировать их в нужный внутренний формат. Если бы printf() выполняла ввод, а не вывод, ее можно было бы назвать аналогом scanf().

Управляющая строка, на которую указывает format, состоит из символов трех типов:

• Спецификаторы формата
• Специальные символы
• Прочие символы (не специальные)

Спецификаторы формата следуют за символом процент и сообщают scanf(), данные какого типа будут считаны следующими. Коды спецификаторов приведены в таблице.

Табпица: Коды форматов для 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.)

Функция scanf() представляет собой процедуру общего назначения, которая читает поток stdin и сохраняет информацию в переменных, заданных аргументами, перечисленными в списке аргументов. Она может читать все встроенные типы данных и автоматически преобразовывать их в соответствующий внутренний формат.

В версии С99 к параметру format применен квалификатор restrict.

Управляющая строка, задаваемая параметром format, состоит из символов трех категорий:

• спецификаторов формата;
• пробельных символов;
• символов, отличных от пробельных.

Спецификаторы формата - им предшествует знак процента(%) - сообщают, какого типа данное будет прочитано следующим. Например, спецификатор %s прочитает строку, а %d - целое значение. Строка форматирования читается слева направо, и спецификаторы формата по порядку сопоставляются с аргументами, перечисленными в списке аргументов. Эти коды приведены в следующей таблице.

Код	Назначение
%а	Читает значение с плавающей точкой(только С99)
%А	Аналогично коду %a (только С99)
%с	Читает один символ
%d	Читает десятичное целое
%i	Читает целое в любом формате(десятичное, восьмеричное, шестнадцатеричное)
%е	Читает вещественное число
%Е	Аналогично коду %е
%f	Читает вещественное число
%F	Аналогично коду %f(только С99)
%g	Читает вещественное число
%G	Аналогично коду %g
%о	Читает восьмеричное число
%s	Читает строку
%х	Читает шестнадцатеричное число
%X	Аналогично коду %х
%р	Читает указатель
%n	Принимает целое значение, равное количеству символов, прочитанных до сих пор
%u	Читает десятичное целое без знака
%	Просматривает набор символов
%%	Читает знак процента

По умолчанию спецификаторы а, f, e и g заставляют функцию scanf() присваивать данные переменным типа float. Если поставить перед одним из этих спецификаторов формата модификатор l, функция scanf() присвоит прочитанное данное переменной типа double. Использование же модификатора L означает, что переменная, принимающая значение, имеет тип long double.

Если вы используете современный компилятор, который поддерживает добавленные в 1995 году средства работы с двухбайтовыми символами, можете задействовать модификатор l применительно к спецификатору с, чтобы обозначить указатель на двухбайтовый символ с типом данных whcar_t. Модификатор l можно также использовать с кодом формата s, чтобы обозначить указатель на строку двухбайтовых символов. Кроме того, модификатор l можно использовать для модификации набора сканируемых двухбайтовых символов.

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

Не пробельный символ в строке форматирования заставляет функцию scanf() прочитать и отбросить соответствующий символ. Например, при использовании строки форматирования %d, %d функция scanf() сначала прочитает целое значение, затем прочитает и отбросит запятую и наконец прочитает еще одно целое. Если заданный символ не обнаружится, работа функции scanf() будет завершена.

Все переменные, используемые для приема значений с помощью функции scanf(), должны передаваться посредством их адресов. Это значит, что все аргументы должны быть указателями на переменные.

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

Scanf("%d%d", &r, &c);

примет значения, введенные как 10 20, но наотрез откажется от "блюда", поданного в виде 10,20.

Символ *, стоящий после знака % и перед кодом формата, прочитает данные заданного типа, но запретит их присваивание. Следовательно, оператор

Scanf("%d%*c%d", &х, &у);

при вводе данных в виде 10/20 поместит значение 10 в переменную х, отбросит знак деления и присвоит значение 20 переменной у.

Команды форматирования могут содержать модификатор максимальной длины поля. Он представляет собой целое число, располагаемое между знаком % и кодом формата, которое ограничивает количество символов, читаемых для любого поля. Например, если вы хотите прочитать в переменную address не более 20 символов, используйте следующий оператор.

Scanf("%20s", address);

Если входной поток содержит более 20 символов, то при последующем обращении к операции ввода чтение начнется с того места, в котором "остановился" предыдущий вызов функции scanf(). При обнаружении пробельного символа ввод данных для поля может завершиться до достижения максимальной длины поля. В этом случае функция scanf() переходит к чтению следующего поля.

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

Scanf("%с%с%с", &а, &Ь, &с);

поместит символ х в переменную а, пробел - в переменную Ь и символ у - в переменную с.

Помните, что любые другие символы управляющей строки, не являющиеся спецификаторами формата(включая пробелы, символы табуляции и новой строки), используются для установления соответствия и отбрасывания символов из входного потока. Например, если поток ввода выглядит, как 10t20, оператор

Scanf("%st%s", &х, &у);

поместит 10 в переменную х и 20 - в переменную у. Символ t отбрасывается, так как он присутствует в управляющей строке.

Еще один способ использования функции scanf() называется набором сканируемых символов(scanset). В этом случае определяется набор символов, которые могут быть прочитаны функцией scanf() и присвоены соответствующему массиву символов. Для определения такого набора необходимо заключить символы, подлежащие сканированию, в квадратные скобки. Открывающая квадратная скобка должна следовать сразу за знаком процента. Например, следующий набор сканируемых символов говорит о том, что необходимо прочитать только символы А, В и С.

%[АВС]

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

Если первый символ в наборе является знаком вставки(^), то получаем обратный эффект: входное поле читается до первого символа из заданного набора символов, т.е. знак вставки заставляет функцию scanf() принимать любые символы, которые не определены в наборе.

Многие компиляторы позволяют с помощью дефиса задать диапазон. Например, следующий оператор заставляет функцию scanf() принимать символы от А до Z.

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

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

Модификаторы формата, добавленные к функции scanf() стандартом С99

В версии С99 добавлено несколько модификаторов формата для использования в функции scanf(): hh, ll, j, z и t. Модификатор hh можно применять к спецификаторам d, i, о, и, х и п. Он означает, что соответствующий аргумент является указателем на значение типа signed char или unsigned char. Модификатор ll также можно применять к спецификаторам d, i, о, и, х и п. Он означает, что соответствующий аргумент является указателем на значение типа signed long long int или unsigned long long int.

Модификатор формата j, который применяется к спецификаторам d, i, о, и, х и n, означает, что соответствующий аргумент является указателем на значение типа intmax_t или uintmax_t. Эти типы объявлены в заголовке и служат для хранения целых максимально возможной длины.

Модификатор формата z, который применяется к спецификаторам d, i, о, u, x и n, означает, что соответствующий аргумент является указателем на объект типа size_t. Этот тип объявлен в заголовке и служит для хранения результата операции sizeof.

Модификатор формата t, который применяется к спецификаторам d, i, о, u, x и n, означает, что соответствующий аргумент является указателем на объект типа ptrdiff_t. Этот тип объявлен в заголовке и служит для хранения значения разности между двумя указателями.