Основы программирования

Символьные строки,
директива #define,
функции printf( ) и scanf( )

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

/* непринужденный разговор */
# define DENSITY 62 4  /* плотность тела человека в фунтах на кубический фут */
main( )  /* любопытствующая программа*/
{
  float weight, volume;
  int size, letters;
  char name [40];   /* или попробуйте "static char name [40], */
  printf(" Привет! Как вас зовут?\n" );
  scanf(" %s" , name);
  printf("%s,  Каков ваш вес в фунтах?\n", name);
  scani("%f", &weight);
  size = sizeof name;
  letters = strlen (name);
  volume = weight/DENSITY;
  printf(" Прекрасно, %s, ваш объем %2 2f кубических фута.\n", name, volume);
  printf(" Кроме того, ваше имя состоит из %d букв,\n", letters);
  printf(" и для его размещения в памяти у нас есть %d байт.\n", size);
}

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

Привет ! Как вас зовут?
Анжелика
Анжелика  Каков ваш вес в фунтах?
102,5
Прекрасно, AНЖЕЛИКА ваш объем 1,64 кубических фута
Кроме того, ваше имя состоит из 8 букв
и для его размещения в памяти у нас есть 40 байт 

Перечислим основные новые черты этой программы:
1. Мы использовали "массив" для хранения "символьной строки" - в данном случае для некоторого имени.
2. При вводе и выводе строки была использована "спецификация преобразования" %s.
3. Для определения символической константы DENSITY был использован препроцессор языка Си.
4. Для нахождения длины строки была использована функция strlen( ).

Способ ввода-вывода, реализованный в языке Си, может показаться вначале несколько более сложным по сравнению с вводом-выводом, предусмотренным, например, в Бейсике. Однако эта сложность окупается улучшенными возможностями управления вводом-выводом и большей эффективностью получаемых программ. Указанная трудность - не единственная, с которой вы столкнетесь в дальнейшем. Давайте исследуем все новые моменты более детально.

"Символьная строка" - это последовательность, состоящая из одного или более символов В качестве примера рассмотрим следующую строку:

"Строки изливались прямо из сердца!"

Кавычки не являются частью строки. Они вводятся только для того, чтобы отметить ее начало и конец, т.е. играют ту же роль, что и апострофы в случае одиночного символа.

В языке Си нет специального типа, который можно было бы использовать для описания строк Вместо этого строки представля ются в виде "массива" элементов типа char. Это означает, что символы в строке можно представить себе расположенными в со седних ячейках памяти - по одному символу в ячейке (рис. 41).

Необходимо отметить, что на рисунке последним элементом массива является символ \0. Это "нуль-символ", и в языке Си он используется для того, чтобы отмечать конец строки Нуль-символ - не цифра 0; он не выводится на печать и в таблице кода ASCII¹⁾ имеет номер 0. Наличие нуль-символа означает, что количество ячеек массива должно быть по крайней мере на одну больше, чем число символов, которые необходимо размещать в памяти.

Ну, а теперь спросим, что такое массив? Массив можно пред ставить себе как совокупность нескольких ячеек памяти, объединен ных в одну строку Если вы предпочитаете более формальные и строгие определения, то массив - это упорядоченная последова тельность элементов данных одного типа В нашем примере мы со здали массив из 40 ячеек памяти, в каждую из которых можно по местить один элемент типа char. Мы осуществили это с помощью оператора описания

char name [40];

Квадратные скобки указывают, что переменная name - массив, 40 - число его элементов, a char задает тип каждого элемента. (В комментариях к программе было отмечено, что при желании вы можете воспользоваться более сложным оператором описания).

static char name [40],

Ввиду некоторой специфики, связанной с реализацией функции scanf( ) в нашей системе, мы вынуждены использовать эту вторую

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

На первый взгляд все это выглядит довольно сложным: вы должны создать массив, расположить символы в виде строки и не забыть добавить в конце \0. К счастью, о большинстве деталей компилятор может "позаботиться" сам.

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

/* похвала 1*/
#define PRAISE " Вот эта да, какое великолепное имя"
main( )
{
char name [50];
printf(" Как вас зовут? \n" );
scanf(" %s", name);
printf(" Привет, %s %s\n" , name, PRAISE);
}

Символ %s служит указанием функции printf( ) напечатать строку. Результат выполнения программы похвала 1 может выглядeть, например, так

Как вас зовут ?
Элмо Бланк Привет, Элмо,  Вот эта да, какое великолепное имя !

Как видите, нам не пришлось самим помещать нуль символ в конец массива. Эта задача была выполнена за нас функцией scanf( ) при чтении вводимой строки. PRAISE - "символическая строковая константа". Ниже мы рассмотрим директиву #define более подробно, а пока вы должны знать, что кавычки, в которые за ключена фраза, следующая за строковой константой PRAISE, иден тифицируют эту фразу как строку, и поэтому в ее конец будет помещен нуль-символ.

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

Необходимо заметить также, что строка "х" не то же самое, что символ 'x'. Первое различие: 'х' - объект одного из основных типов (Char), в то время как "х" - объект производного типа (массива элементов типа char). Второе различие: "х" на самом де ле состоит из двух символов - символа 'x' и нуль-символа.

В предыдущей главе мы практически без объяснений использовали операцию sizeof, которая дает нам размер объектов в байтах Функция strlen( ) позволяет определять длину строки числом символов. Поскольку для размещения одного символа в памяти отводится 1 байт, можно было бы предположить, что в результате применения любой из этих двух операций к одной строке будет получен одинаковый результат. Оказыватся, это не так. Давайте немного изменим нашу предыдущую программу (добавим к ней несколько строк), и тогда мы поймем, в чем дело.

/*похвала 2*/
#define PRAISE " Вот это да, какое великолепное имя!"
main( )
{
char name [50];
printf(" Как вас зовут?\n");
scanf(" %s", name);
printf(" Привет, %s. %s\n" , name, PRAISE);
printf(" Ваше имя состоит из %d букв и занимает %d ячеек памяти. \n",
strlen (name), sizeof name);
printf(" Хвалебная фраза состоит из %d букв", strlen (PRAISE));
printf(" и занимает %d ячеек памяти. \n", sizeof PRAISE);
}

Заметим, что случайно мы воспользовались двумя методами для обработки длинных операторов printf(). В первом случае мы записав один оператор печати в двух строках программы²⁾ . Мы сделали это, поскольку разрешается разбивать строку между аргументами, но не посередине строки. В другом случае использовались два оператора printf() для печати одной строки; мы указали символ "новая строка" (\n) только во втором из них. Представленный ниже результат работы данной программы поможет понять подобную ситуацию:

Как вас зовут ?
Перки
Привет, Перки. Вот это да, какое великолепное имя!
Ваше имя состоит из 5 букв и занимает 50 ячеек памяти.
Хвалебная фраза состоит из 35 букв и занимает 36 ячеек памяти.

Давайте посмотрим, в чем дело. Массив name занимает 50 ячеек памяти, и именно об этом сообщает операция sizeof. Но для хранения имени Перки требуются только первые пять ячеек, и как раз об этом нас информирует функция strlen( ). В шестой ячейке массива name содержится нуль-символ, и его появление служит сигналом для функции strlen( ) прекратить подсчет символов

При переходе к обработке константы PRAISE обнаруживается, что функция strlen( ) опять дает нам точное число символов (включая пробелы и знаки пунктуации) в строке. Результат операции sizeof оказывается на единицу большим, поскольку при этом учи тывается и "невидимый" нуль-символ, помещенный в конец строки. Мы не указываем компилятору, какой объем памяти он должен отвести для размещения всей фразы, он сам подсчитывает число символов между кавычками.

Еще одно замечание в предыдущей главе была использована операция sizeof со скобками, а в этой - без них. Решение, исполь зовать ли скобки или нет, зависит от того, что вы хотите знать объем памяти, отводимый под элементы конкретного типа, или объем памяти, занимаемый определенным объектом В первом слу чае вы писали бы sizeof(char) или sizeof(float), а во втором - sizeof name или sizeof 6.28.

В данном разделе операции strlen( ) и sizeof использовались только для удовлетворения нашего любопытства, в действительности они представляют собой важные программные средства Функция strlen( ), например, полезна в любого сорта программах обра ботки строк или символов, в чем вы сможете убедиться, ознакомившись с гл 13. Приступим теперь к рассмотрению директивы #define.

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

circ = 3.14 * diameter,

Приведенная здесь константа 3. 14 - известное число p. Чтобы ввести ту или иную константу в программу, нужно указать ее фак тическое значение, как было сделано выше. Однако существуют веские причины использовать вместо этого "символические кон станты", например, мы могли бы применять оператор

circ = pi * diameter,

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

owed = 0 015 * housevl, owed = taxrate * housevl,

Если мы изучаем большую программу, то второй вариант будет нам более понятен.
Во-вторых, предположим, что некоторая константа использова лась в нескольких местах программы и впоследствии возникла не обходимость изменить ее значение - ведь в конце концов и налого вые тарифы (taxrate) меняются, и, к примеру, некое законодатель мое собрание приняло однажды закон впредь считать число p равным 3¹/₇. (Весьма вероятно, что окружности пришлось при этом скрываться от правосудия). В таком случае требуется только изменить определение символической константы, а не отыскивать каждый случай ее появления в программе.

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

float taxrate, taxrate = 0 015,

Такой способ подходит для небольшой программы, в других же случаях он несколько неэкономичен, поскольку каждый раз при использовании переменной taxrate компьютер должен будет обращаться к той ячейке памяти, которая отведена данной переменной Это служит примером подстановки "во время выполнения", так как она производится именно при выполнении программы. К счастъю, в языке Си имеется и другой, лучший способ.

Этот способ реализуется с помощью препроцессора языка Си В гл. 2 мы уже видели, как препроцессор использует директиву #include для включения информации из другого файла в программу. Кроме того, препроцессор дает нам возможность задавать константы Для этого в начало файла, содержащего вашу программу, необходимо добавить только одну строку, аналогичную следующей

#define TAXRATE  0.015

При компиляции программы каждый раз, когда появится переменная TAXRATE, она будет заменяться величиной 0.015. Это называ ется подстановкой "во время компиляции". К тому моменту, когда вы начнете выполнение своей программы, все подстановки будут уже сделаны.

Несколько замечаний по поводу формата. Сначала идет ключевое слово #define. Оно должно начинаться с самой левой позиции. Потом следует символическое имя константы, а затем ее величина. Символ "точка с запятой" не используется, поскольку это не оператор языка Си. Почему имя TAXRATE пишется прописными буква ми? В процессе использования языка Си выработалась традиция писать константы прописными буквами. Если при просмотре программы вам встретится имя, написанное прописными буквами, вы сразу поймете, что имеете дело с константой, а не с переменной. Это еще один способ улучшить читаемость программы. Ваша программа будет работать даже и тогда, когда вы будете писать кон станты строчными буквами, но при этом вы должны чувствовать свою вину, поскольку нарушаете традицию.
Приведем простой пример³⁾

/* пицца */
#define PI  3,14159
main( ) /* изучение вашей пиццы */
{
float area, circum, radius;
printf("Чемy равен радиус вашей пиццы? \n");
scanf("%f", &radius);
area = PI * radius * radius;
printf(" Основные параметры вашей пиццы следующие \n");
printf(" длина окружности = %1.2f, площадь =%1.2f \n circum, area);
}

Использование спецификации %1.2f в операторе printf( ) приведет к тому, что при печати результаты будут округлены до двух десятичных цифр. Мы понимаем, конечно, что написанная выше программа может и не отражать ваши собственные вкусы, касаю щиеся пиццы, но во множестве программ, посвященных этому вопросу, она займет свое скромное место. Вот один из примеров ее выполнения.

Чему равен радиус вашей пиццы ? 6.0
Основные параметры вашей пиццы следующие: длина окружности = 37.70,
площадь окружности = 113.40.

Директиву #define можно также использовать для определения символьных и строковых констант. Необходимо использовать знак "апостроф" в первом случае и кавычки - во втором. Примеры, приведенные ниже, вполне правомерны

#define ВЕЕР  '\007'
#define ESS 'S'
#deline NULL '\0'
#define OOPS  "Ну вот, вы и сделали это!"

А теперь мы хотим обрадовать лентяев. Предположим, вы раз рабатываете целый пакет программ, использующих один и тот же набор констант. Вы можете произвести следующие действия:
1. Соберите все ваши директивы #define в один файл и назовите его, например, const.h.
2. В начало каждого файла⁴⁾ , содержащего программу, включите директиву #include "const.h."

Тогда, если вы будете выполнять программу, препроцессор прочтет файл с именем const.h и использует все директивы #define вашей программы. Получилось так, что символ .h в конце имени файла напомнит вам, что этот файл является "заголовком", т.е. в нем содержится вся информация, которая должна попасть в начало вашей программы. Самому препроцессору безразлично, используете ли вы символ .h в имени файла или нет.

Возможности директивы #define не исчерпываются только символическим представлением констант. Рассмотрим, например, cледующую программу:

#include "alias. h"
program begin
whole yours, mine then
spitout(" Введите, пожалуйста, целое число.\n" )
then takem(" %d", & yours)
then mine = yours times TWO then
spitout(" %d в два раза больше вашего числа! \n" , mine) then end

Странно, текст что-то смутно напоминает, язык немного похож на Паскаль, но программа не похожа на Си-программу. Секрет лежит, конечно, в файле с именем alias.h. Давайте посмотрим, что в нем содержится?

alias. h #define program main( )
#define degin { #define enf  } #define then;
#define takein   scanf
#define spilout   printf
#define TWO  2
#define times   *
#define whole int

Этот пример иллюстрирует, как работает препроцессор. Он просматривает вашу программу и проводит поиск элементов, определяемых директивами #define. Обнаружив такие элементы, он полностью заменяет их. В нашем примере во время компиляции все слова then заменяются символами "точка с запятой", end - } и т.д. Результирующая программа будет полностью идентична той, которую мы могли бы получить, если бы с самого начала писали ее в обычных терминах языка Си.

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

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

#define MN "минимифидианизм"
printf(" Oн глубоко верил в MN.\n");

Распечатка будет выглядеть так:

Oн глубоко верил в MN.

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

printf(" Он глубоко верил в %s.\n" , MN);

мы получим следующий результат:

Он глубоко верил в минимифидианизм.

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

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

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

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

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

Приведем программу, иллюстрирующую обсуждаемые вопросы

/* печать чепухи*/
#define PI  3.14159
main( )
{  
      number = 5;
      float ouzo =13,5;
      int cost = 31000;
      printf("%d женщин выпили %f стаканов ликера. \n",
               number, ouzo);
      printf(" Значение числа pi равно %f \n", PI);
      printf(" Прощай! Твое искусство слишком дорого для меня \n");
     printf(" %c%d\n", '$', cost);
}

Результат выглядит так:

5 женщин выпили 13,50000 стаканов ликера.
Значение числа pi равно 3,14159.
Прощай! Твое искусство слишком дорого для меня.
$31000

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

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

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

printf(" %d женщин выпили %f стаканов ликера. \n" , number, ouzo);

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

Приведем еще пример.

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

На этот раз список аргументов содержит только один элемент - символическую константу PI.
Мы видим, что в управляющей строке содержится информация двух различных видов:
1. Символы, печатаемые текстуально.
2. Идентификаторы данных, называемые также "спецификациями преобразования".

Каждому аргументу из списка, следующего за управляющей строкой, должна соответствовать одна спецификация преобразования. Горе вам, если вы забудете это основное требование. Никогда не пишите, например, так:

printf(" Количество слизняков %d, червяков %d.\n", scorel);

3десь отсутствует аргумент для второй спецификации преобразования %d. Способ проявления этой ошибки целиком зависит от вашей вычислительной системы, но в лучшем случае вы получите бессмыслицу.

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

printf(" Прощай! Твое искусство слишком дорого для меня.\n");
printf(" %c%d\n" , '$', cost);

Заметим, что во втором примере первый аргумент из печатаемого списка является символьной константой, а не переменной.

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

рс = 2*6;
printf("Только %d%% стряпни Салли было съедобно.\n", рс);

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

Только 12%  стряпни Салли было съедобно.

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

Посмотрим, как эти модификаторы работают. Начнем с того, что продемонстрируем влияние модификатора ширины поля на печать целого числа. Рассмотрим следующую программу:

main( )
{
  printf("/%d/\n", 336);
  printf("/%2d/\n", 336);
  printf("/%10d/\n", 336);
  printf("/%-10d/\n", 366);
}

Эта программа печатает одно и то же значение четыре раза, но используются при этом четыре различные спецификации преобразования. Мы вводим также символы /, чтобы вы могли видеть, где начинается и кончается каждое поле. Результат выполнения программы выглядит следующим образом:

/336/ /336/
/      336 /336       /

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

Рассмотрим теперь некоторые форматы, соответствующие данным с плавающей точкой. Допустим, у нас имеется следующая программa:

main( )
{
       printf(" /%f/\n" , 1234.56);
      printf(" /%e/\n" , 1234.56);
      printf(" /%4.2f/\n" , 1234.56);
   printf(" /%3.1f/\n", 1234.56);
    printf(" /%10.3f/\n" , 1234.56);
  printf(" /%10.3e/\n" , 1234.56);
}

На этот раз результат работы программы будет выглядеть так

   /1234.560059/
     /1.234560E+03/
    /1234.56/
 /1234.6/
  /   1234.560/
     / 1.234E+03/

Мы снова начинаем с варианта, выбранного по умолчанию, т. е. сo спецификации %f. В этом случае имеется две величины, значене которых используются по умолчанию: ширина поля и число цифр справа от десятичной точки. Вторая величина задает шесть цифр, ширина поля берется такой, чтобы в нем могло поместиться число. Заметим, что печатаемое число несколько отличается от исходного Это происходит потому, что на печать выводится 10 цифр, в то время как числа с плавающей точкой в нашей системе изображаются приблизительно с точностью до 6 или 7 цифр.

Рассмотрим вариант по умолчанию для спецификации %е. Как мы видим, при ее использовании печатается одна цифра слева от десятичной точки и шесть справа. В результате получается слишком много цифр! Чтобы избежать этого, необходимо задать число цифр справа от десятичной точки, и последние четыре опера тора программы реализуют как раз указанную возможность Обратите внимание на то, как четвертый и шестой операторы производят округление выводимых данных.
Теперь исследуем некоторые варианты строк. Рассмотрим пример:

#define BLURB "Выдающееся исполнение"
main( )
{
printf(" /%2s/\n" , BLURB);
printf(" /'%25.s/\n" , BLURB);
printf(" /'%25.5s/\n" , BLURB);
printf(" /% - 25.5s/\n" , BLURB);
} 

Boт результат работы программы:

/Выдающееся исполнение!/
/   Выдающееся исполнение!/
/                                Выдаю/ /Выдаю                                  /

Обратите внимание на то, как поле расширяется для того, чтобы поместились все указанные символы. Заметим также, как спецификация точности ограничивает число символов, выводимых на ПЕЧАТЬ. Символы .5 в спецификации формата указывают функции printf( ) на необходимость напечатать только пять символов.

Теперь вы ознакомились с некоторым количеством примеров. А знаете ли вы, как подготовить оператор печати, чтобы напечатав нечто вроде следующей фразы:

Семья NAME, возможно, лишь на XXX.XX долларов богаче!

Здесь NAME и ХХХ.ХХ представляют значения соответствующих переменных в программе, скажем name[40] и cash. Вот одно из решений:

printf(" Семья %s, возможно, лишь на %.2f долларов
богаче! \n", name, cash);

До сих пор мы без тени сомнения применяли спецификации преобразования для переменных разных типов, например, %f для типа float и т. д. Но, как мы уже видели в нашей программе поиска кода ASCII, для некоторого символа функцию printf() можно исполь зовать также для преобразования данных из одного типа в другой. Мы не намерены, однако, терять чувство реальности и по прежнему будем работать с целыми типами.

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

main( )
{
printf(" %d\n", 336);
printf(" %o\n", 336);
printf(" %x\n", 336);
printf(" %d\n",  -336);
printf(" %u\n",  -336);
}

В нашей системе результат будет выглядеть следующим образом

336
520
150
-336
-65200

Как вы, по-видимому, и ожидали, при использовании спецификации %d будет получено число 336 точно так же, как в примере, обсуждавшемся чуть выше. Но давайте посмотрим, что произойдет, когда вы "попросите" программу напечатать это десятичное целое число в восьмеричном коде. Она напечатает число 520, являющееся восьмеричным эквивалентом 336 (5х64+2х8+0х 1= 336). Аналогично при печати этого числа в шестнадцатеричном коде мы получим 150.

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

Сделаем еще несколько замечаний относительно вывода на печать. Печать числа -336 при использовании спецификации %d не вызывает никакого затруднения. При применении же спецификации %u (unsigned - беззнаковая) получаем число 65200, а не 336, как можно было бы ожидать. Причина получения такого результата лежит в способе представления отрицательных чисел в нашей системе. Здесь используется так называемый "дополнительный код". Числа от 0 до 32767 отображаются обычным образом, а от 32768 до 65535 представляют отрицательные числа, причем 65535 кодирует число -1, 65534 - число -2 и т. д. Поэтому числу -336 соответствует 65536, -336 = 65200. Этот метод применяется не во всех системах. Тем не менее отсюда следует вывод: не ожидайте, что спецификация преобразования %u приводит просто к отбрасыванию знака числа.

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

printf(" %c%d\n" , ' А', ' А');

выдаст следующий результат:

A 65 

А - это буква, а 65 - десятичный код ASCII символа А. Мы могли бы использовать спецификацию %о, если бы хотели получить восьмеричный код ASCII символа А.

Все вышесказанное дает хороший способ нахождения кодов ASCII для различных символов и наоборот. Вполне возможно, конечно, что вы предпочтете ему поиск кодов в приложении Ж. Что произойдет, если вы попробуете преобразовать число, больше 255, в символ? Следующая строка и результат ее выполнения дадут ответ на этот вопрос:

printf(" %d %c\n" , 336, 336);
336 P

Десятичный код ASCII символа Р равен 80, а 336 - это 256 + 80. Данное число, очевидно, интерпретируется по модулю 256. (Это математический термин, обозначающий остаток от деления числа на 256.) Другими словами, всякий раз при получении чис ла, кратного 256, отсчет начинается сначала, и 256 рассматривается как 0, 257 - как 1, 511 - как 255, 512 - как 0, 513 - как 1 и т. д.

И наконец, попытаемся напечатать число (65616), превышающее максимальное значение, которое могут принимать данные типа int в нашей системе (32767):

printf(" %1d %d\n" , 65616, 65616);

Результат будет выглядеть так:

65616   80

Мы снова видим, что действия выполняются по "модулю" На этот раз счет ведется группами по 65536. Числа между 32767 и 65536 будут выводиться на печать как отрицательные из-за способа их представления в памяти машины. Системы с разными размера ми ячеек памяти, отводимых под данные целого типа, ведут себя в общем одинаково, но при этом дают разные числовые значения.

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

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

Так же как для функции printf( ), для функции scanf( ) указыва ются управляющая строка и следующий за ней список аргументов. Основное различие двух этих функций заключается в особенности данного списка. Функция printf( ) использует имена переменных константы и выражения, в то время как функция scanf( ) - только указатели на переменные. К счастью, при применении этой функ ции мы ничего не должны знать о таких указателях. Необходимо помнить только два правила:
1. Если вам нужно ввести некоторое значение и присвоить его переменной одного из основных типов, то перед именем nepеменной требуется писать символ &.
2. Если вы хотите ввести значение строковой переменной, использовать символ & не нужно.

Приведем правильную программу

main( )
{
int age;
float assets;
char pet [30];
printf(" Укажите ваш возраст, состояние и любимое животное.\n" );
scanf(" %d  %f" , &age, &assets);
scanf(" %s" , pet);  /* & отсутствует при указании массива
символов */ printf("%d  $%.0f  %s\n", age, assets, pet);
} 

Вот пример диалога:

Укажите ВАШ ВОЗРАСТ, состояние и любимое животное.
82
8345245.19  носорог
82  $8345245  носорог

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

Функция scanf( ) использует практически тот же набор символов спецификации преобразования, что и функция printf( ). Основные отличия в случае функции scanf( ) следующие:
1. Отсутствует спецификация %g.
2. Спецификации %f и %е эквивалентны. Обе спецификации до пускают наличие (или отсутствие) знака, строки цифр с десятичной точкой или без нее и поля показателя степени.
3. Для чтения целых чисел типа short применяется спецификация %h.

Функция scanf( ) не является одной из наиболее часто используемых функций языка Си. Мы обсуждаем ее здесь главным образом из-за ее универсальности (она позволяет читать данные всех имею щихся типов); однако в Си имеется еще несколько других функций, осуществляющих ввод, например getchar( ) и gets( ), которые более удобны для выполнения конкретных задач - чтения одиночных символов или строк, содержащих пробелы. Мы рассмотрим неко торые из этих функций в гл. 6, 13 и 15.

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

printf(" %d %d %d\n" , val1, val2, val3);

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

12  234  1222
4  5  23
22334  2322  10001

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

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

printf( %9d %9d %9d\n" , val1, val2, val3);

результат будет выглядеть так:

      12     234    1222
        4         5        23
22334   2322  10001

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

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

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

printf(" Скороход Беппо пробежал %.2f мили за 3 ч.\n", distance);

могла бы быть следующая фраза:

Скороход Беппо пробежал 10.22  мили за 3 ч.

Изменяя спецификацию преобразования на %10.2f, получим

Скороход Беппо пробежал                  10.22 мили за 3 ч.

Что такое строка символов: несколько символов, расположенных в ряд.
Как записывать строку символов: " несколько символов, расположенных в ряд".
Как строка хранится в памяти: " несколько символов, расположенных в ряд\0".
Где разместить строку: char phrase[25] или static char phrase[25].
Как определить длину строки: использовать функцию strlen(строка).
Как распечатать строку: printf(" %s", phrase).
Как прочитать строку, состоящую из одного слова: scanf(" %s " ,&name).
Как задать числовую константу: #define TWO 2.
Как задать символьную константу: #define WOW '!'.
Как задать строковую константу: #define WARN "He делай этого!".
Спецификации преобразования при вводе-выводе: %d %f %e %g %c %s %u % o %х.
Как улучшить вид входной информации: %-10d %3.2f.
Как выполнять преобразования: printf(" %d %о %c\h", WOW, WOW, WOW);

Вопросы

1. Выполните снова программу, приведенную в начале данной главы, но на этот раз в ответ на вопрос о вашем имени введите имя и фамилию. Что произойдет? Почему?

2. Что выведет на печать каждый из нижеприведенных программных фрагментов в предположении, что они являются частью некоторой полной программы?
a. printf( "Oн продал картину за $%2 2f \n", 2 345е2),
б. printf("%c%c%c\n", 'Н', 105, '\41'),
в. #define Q "Его Гамлет был смешным, но не вульгарным "
printf("%s\n имеет %d символов \n", Q, strlen(Q)),
г. printf("%2 2е то же самое, что и %2 2f?\n", 1201 0, 1201 0),

3. Какие изменения необходимо внести в программу п. 2в, чтобы строка Q была вы ведена на печать заключенной в апострофы?

4. Очередная задача по обнаружению ошибок в программе

define В а-яй яй
define X 10
main( )
{ I
int age, char name,
printf(" Укажите, пожалуйста, свое имя ");
scanf(" % s", name);
printf(" Прекрасно, %с, сколько вам лет?\n", name);
scanf(" %f , age), xp = age + X;
printf(" %s  Вам должно быть по крайней мере %d \n", В, xp),
}

Ответы

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

2.     а. Он продал картину за 234 50 долл
б. Hi!Примечание: первый символ - это символическая константа, второй - деся тичное целое число, преобразованное в символ, а третий - представлен символической константы в коде ASCII.
в. Его Гамлет был смешным, но не вульгарным имеет 41 символ.
г. 1.20Е+03 то же самое, что и 1201,00?

3. Вспомните, что в гл 3 говорилось по поводу управляющих последовательностей, и попробуйте записать оператор в таком виде printf(" \" %s \" \n имеет %d символов \n", Q, strlen(Q)).

4. Строка 1: символ # опущен; вместо а-яй-яй должно стоять "а-яй-яй"
Строка 2: символ # опущен
Строка 6: переменная name должна быть массивом, например char name[25]
Строка 8: в управляющей строке должен стоять символ \n
Строка 10: вместо %с должно быть %s
Строка 11 поскольку переменная аgе целого типа, необходимо использовать %d, а не %f, кроме того, вместо аgе должно стоять &аgе
Строка 12: имя xp нигде не было описано
Строка 13: правильная, но при выводе на печать результат будет испорчен из-за ошибки, допущенной при определении В
Кроме того, программа служит примером плохого стиля программирования.