правила о том, в каком случае целые преобразу- ются к типу с плаваюшей точкой, приведены в главе 2. Сейчас же отметим, что присваивание FAHR = LOWER; проверка WHILE (FAHR <= UPPER) работают, как ожидается, - перед выполнением операций целые преобразуются в плавающую форму. Этот же пример сообщает чуть больше о том, как работает PRINTF. Функция PRINTF фактически является универсальной функцией форматных преобразований, которая будет полностью описана в главе 7. Ее первым аргументом является строка сим- волов, которая должна быть напечатана, причем каждый знак % указывает, куда должен подставляться каждый из остальных ар- гументов /второй, третий, .../ и в какой форме он должен пе- чататься. Например, в операторе PRINTF("%4.0F %6.1F\N", FAHR, CELSIUS); спецификация преобразования %4.0F говорит, что число с пла- вающей точкой должно быть напечатано в поле шириной по край- ней мере в четыре символа без цифр после десятичной точки. спецификация %6.1F описывает другое число, которое должно занимать по крайней мере шесть позиций с одной цифрой после десятичной точки, аналогично спецификациям F6.1 в фортране или F(6,1) в PL/1. Различные части спецификации могут быть опущены: спецификация %6F говорит, что число будет шириной по крайней мере в шесть символов; спецификация %2 требует двух позиций после десятичной точки, но ширина при этом не ограничивается; спецификация %F говорит только о том, что нужно напечатать число с плавающей точкой. Функция PRINTF также распознает следующие спецификации: %D - для десятично- го целого, %о - для восьмеричного числа, %х - для шестнадца- тиричного, %с - для символа, %S - для символьной строки и %% - для самого символа %. Каждая конструкция с символом % в первом аргументе функ- ции PRINTF сочетается с соответствующим вторым, третьим, и т.д. Аргументами; они должны согласовываться по числу и ти- пу; в противном случае вы получите бессмысленные результаты. Между прочим, функция PRINTF не является частью языка "C"; в самом языке "C" не определены операции ввода-вывода. Нет ничего таинственного и в функции PRINTF ; это - просто полезная функция, являющаяся частью стандартной библиотеки подпрограмм, которая обычно доступна "C"-программам. Чтобы сосредоточиться на самом языке, мы не будем подробно оста- навливаться на операциях ввода-вывода до главы 7. В частнос- ти, мы до тех пор отложим форматный ввод. Если вам надо ввести числа - прочитайте описание функции SCANF в главе 7, раздел 7.4. Функция SCANF во многом сходна с PRINTF , но она считывает входные данные, а не печатает выходные. Упражнение 1-3 ---------------- Преобразуйте программу перевода температур таким обра- зом, чтобы она печатала заголовок к таблице. Упражнение 1-4 ---------------- Напишите программы печати соответствующей таблицы пере- хода от градусов цельсия к градусам фаренгейта. 1.3. Оператор FOR Как и можно было ожидать, имеется множество различных способов написания каждой программы. Давайте рассмотрим та- кой вариант программы перевода температур: MAIN() /* FAHRENHEIT-CELSIUS TABLE */ { INT FAHR; FOR (FAHR = 0; FAHR <= 300; FAHR = FAHR + 20) PRINTF("%4D %6.1F\N", FAHR, (5.0/9.0)*(FAHR-32.0)); } Эта программа выдает те же самые результаты, но выглядит безусловно по-другому. Главное изменение - исключение боль- шинства переменных; осталась только переменная FAHR , причем типа INT (это сделано для того, чтобы продемонстрировать преобразование %D в функции PRINTF). Нижняя и верхняя грани- цы и размер щага появляются только как константы в операторе FOR , который сам является новой конструкцией, а выражение, вычисляющее температуру по цельсию, входит теперь в виде третьего аргумента функции PRINTF , а не в виде отдельного оператора присваивания. Последнее изменение является примером вполне общего пра- вила языка "C" - в любом контексте, в котором допускается использование значения переменной некоторого типа, вы можете использовать выражение этого типа. Так как третий аргумент функции PRINTF должен иметь значение с плавающей точкой, чтобы соответствовать спецификации %6.1F, то в этом месте может встретиться любое выражение плавающего типа. Сам оператор FOR - это оператор цикла, обобщающий опера- тор WHILE. Его функционирование должно стать ясным, если вы сравните его с ранее описанным оператором WHILE . Оператор FOR содержит три части, разделяемые точкой с запятой. Первая часть FAHR = 0 выполняется один раз перед входом в сам цикл. Вторая часть - проверка, или условие, которое управляет циклом: FAHR <= 300 это условие проверяется и, если оно истинно, то выполняется тело цикла (в данном случае только функция PRINTF ). Затем выполняется шаг реинициализации FAHR =FAHR + 20 и условие проверяется снова. цикл завершается, когда это ус- ловие становится ложным. Так же, как и в случае оператора WHILE , тело цикла может состоять из одного оператора или из группы операторов, заключенных в фигурные скобки. Инициали- зирующая и реинициализирующая части могут быть любыми от- дельными выражениями. Выбор между операторами WHILE и FOR произволен и основы- вается на том , что выглядит яснее. Оператор FOR обычно удо- бен для циклов, в которых инициализация и реинициализация логически связаны и каждая задается одним оператором, так как в этом случае запись более компактна, чем при использо- вании оператора WHILE , а операторы управления циклом сосре- дотачиваются вместе в одном месте. Упражнение 1-5 --------------- Модифицируйте программу перевода температур таким обра- зом, чтобы она печатала таблицу в обратном порядке, т.е. От 300 градусов до 0. 1.4. Символические константы Последнее замечание, прежде чем мы навсегда оставим программу перевода температур. Прятать "магические числа", такие как 300 и 20, внутрь программы - это неудачная практи- ка; они дают мало информации тем, кто, возможно, должен бу- дет разбираться в этой программе позднее, и их трудно изме- нять систематическим образом. К счастью в языке "C" предус- мотрен способ, позволяющий избежать таких "магических чи- сел". Используя конструкцию #DEFINE , вы можете в начале программы определить символическое имя или символическую константу, которая будет конкретной строкой символов. Впос- ледствии компилятор заменит все не заключенные в кавычки по- явления этого имени на соответствующую строку. Фактически это имя может быть заменено абсолютно произвольным текстом, не обязательно цифрами #DEFINE LOWER 0/* LOWER LIMIT OF TABLE */ #DEFINE UPPER 300 /* UPPER LIMIT */ #DEFINE STEP 20 /* STEP SIZE */ MAIN () /* FAHRENHEIT-CELSIUS TABLE */ { INT FAHR; FOR (FAHR =LOWER; FAHR <= UPPER; FAHR =FAHR + STEP) PRINTF("%4D %6.1F\N", FAHR, (5.0/9.0)*(FAHR-32)); } величины LOWER, UPPER и STEP являются константами и поэ- тому они не указываются в описаниях. Символические имена обычно пишут прописными буквами, чтобы их было легко отли- чить от написанных строчными буквами имен переменных. отме- тим, что в конце определения не ставится точка с запятой. Так как подставляется вся строка, следующая за определенным именем, то это привело бы к слишком большому числу точек с запятой в операторе FOR . 1.5. Набор полезных программ Теперь мы собираемся рассмотреть семейство родственных программ, предназначенных для выполнения простых операций над символьными данными. В дальнейшем вы обнаружите, что многие программы являются просто расширенными версиями тех прототипов, которые мы здесь обсуждаем. 1.5.1. Ввод и вывод символов Стандартная библиотека включает функции для чтения и за- писи по одному символу за один раз. функция GETCHAR() извле- кает следующий вводимый символ каждый раз, как к ней обраща- ются, и возвращает этот символ в качестве своего значения. Это значит, что после C = GETCHAR() переменная 'C' содержит следующий символ из входных данных. Символы обычно поступают с терминала, но это не должно нас касаться до главы 7. Функция PUTCHAR(C) является дополнением к GETCHAR : в результате обращения PUTCHAR (C) содержимое переменной 'C' выдается на некоторый выходной но- ситель, обычно опять на терминал. Обращение к функциям PUTCHAR и PRINTF могут перемежаться; выдача будет появляться в том порядке, в котором происходят обращения. Как и функция PRINTF , функции GETCHAR и PUTCHAR не со- держат ничего экстраординарного. Они не входят в состав язы- ка "C", но к ним всегда можно обратиться. 1.5.2. Копирование файла Имея в своем распоряжении только функции GETCHAR и PUTCHAR вы можете, не зная ничего более об операциях вво- да-вывода, написать удивительное количество полезных прог- рамм. Простейшим примером может служить программа посимволь- ного копирования вводного файла в выводной. Общая схема име- ет вид: ввести символ WHILE (символ не является признаком конца файла) вывести только что прочитанный символ ввести новый символ программа, написанная на языке "C", выглядит следующим обра- зом: MAIN() /* COPY INPUT TO OUTPUT; 1ST VERSION */ { INT C; C = GETCHAR(); WHILE (C != EOF) { PUTCHAR (C); C = GETCHAR(); } } оператор отношения != означает "не равно". Основная проблема заключается в том, чтобы зафиксиро- вать конец файла ввода. Обычно, когда функция GETCHAR натал- кивается на конец файла ввода, она возвращает значение , не являющееся действительным символом; таким образом, программа может установить, что файл ввода исчерпан. Единственное ос- ложнение, являющееся значительным неудобством, заключается в существовании двух общеупотребительных соглашений о том, ка- кое значение фактически является признаком конца файла. Мы отсрочим решение этого вопроса, использовав символическое имя EOF для этого значения, каким бы оно ни было. На практи- ке EOF будет либо -1, либо 0, так что для правильной работы перед программой должно стоять собственно либо #DEFINE EOF -1 либо #DEFINE EOF 0 Использовав символическую константу EOF для представле- ния значения, возвращаемого функцией GETCHAR при выходе на конец файла, мы обеспечили, что только одна величина в прог- рамме зависит от конкретного численного значения. Мы также описали переменную 'C' как INT , а не CHAR , с тем чтобы она могла хранить значение, возвращаемое GETCHAR . как мы увидим в главе 2, эта величина действительно INT, так как она должна быть в состоянии в дополнение ко всем возмож- ным символам представлять и EOF. Программистом, имеющим опыт работы на "C", программа копирования была бы написана более сжато. В языке "C" любое присваивание, такое как C = GETCHAR() может быть использовано в выражении; его значение - просто значение, присваиваемое левой части. Если присваивание сим- вола переменной 'C' поместить внутрь проверочной части опе- ратора WHILE , то программа копирования файла запишется в виде: MAIN() /* COPY INPUT TO OUTPUT; 2ND VERSION */ { INT C; WHILE ((C = GETCHAR()) != EOF) PUTCHAR(C); } Программа извлекает символ , присваивает его переменной 'C' и затем проверяет, не является ли этот символ признаком конца файла. Если нет - выполняется тело оператора WHILE, выводящее этот символ. Затем цикл WHILE повторяется. когда, наконец, будет достигнут конец файла ввода, оператор WHILE завершается, а вместе с ним заканчивается выполнение и функ- ции MAIN . В этой версии централизуется ввод - в программе только одно обращение к функции GETCHAR - и ужимается программа. Вложение присваивания в проверяемое условие - это одно из тех мест языка "C", которое приводит к значительному сокра- щению программ. Однако, на этом пути можно увлечься и начать писать недоступные для понимания программы. Эту тенденцию мы будем пытаться сдерживать. Важно понять , что круглые скобки вокруг присваивания в условном выражении действительно необходимы. Старшинство операции != выше, чем операции присваивания =, а это означа- ет, что в отсутствие круглых скобок проверка условия != бу- дет выполнена до присваивания =. Таким образом, оператор C = GETCHAR() != EOF эквивалентен оператору C = (GETCHAR() != EOF) Это, вопреки нашему желанию, приведет к тому, что 'C' будет принимать значение 0 или 1 в зависимости от того, на- толкнется или нет GETCHAR на признак конца файла. Подробнее об этом будет сказано в главе 2/. 1.5.3. Подсчет символов Следующая программа подсчитывает число символов; она представляет собой небольшое развитие программы копирования. MAIN() /* COUNT CHARACTERS IN INPUT */ { LONG NC; NC = 0; WHILE (GETCHAR() != EOF ) ++NC; PRINTF("%1D\N", NC); } Оператор ++NC; демонстрирует новую операцию, ++, которая означает увеличе- ние на единицу. Вы могли бы написать NC = NC + 1 , но ++NC более кратко и зачастую более эффективно. Имеется соответст- вующая операция -- уменьшение на единицу. Операции ++ и -- могут быть либо префиксными (++NC), либо постфиксными (NC++); эти две формы, как будет показано в главе 2, имеют в выражениях различные значения, но как ++NC, так и NC++ уве- личивают NC. Пока мы будем придерживаться префиксных опера- ций. Программа подсчета символов накапливает их количество в переменной типа LONG, а не INT . На PDP-11 максимальное зна- чение равно 32767, и если описать счетчик как INT , то он будет переполняться даже при сравнительно малом файле ввода; на языке "C" для HONEYWELL и IBM типы LONG и INT являются синонимами и имеют значительно больший размер. Спецификация преобразования %1D указывает PRINTF , что соответствующий аргумент является целым типа LONG . Чтобы справиться с еще большими числами, вы можете ис- пользовать тип DOUBLE / FLOAT двойной длины/. мы также ис- пользуем оператор FOR вместо WHILE с тем, чтобы проиллюстри- ровать другой способ записи цикла. MAIN() /* COUNT CHARACTERS IN INPUT */ { DOUBLE NC; FOR (NC = 0; GETCHAR() != EOF; ++NC) ; PRINTF("%.0F\N", NC); } Функция PRINTF использует спецификацию %F как для FLOAT , так и для DOUBLE ; спецификация %.0F подавляет печать не- существующей дробной части. Тело оператора цикла FOR здесь пусто, так как вся рабо- та выполняется в проверочной и реинициализационной частях. Но грамматические правила языка "C" требуют, чтобы оператор FOR имел тело. Изолированная точка с запятой, соответствую- шая пустому оператору, появляется здесь, чтобы удовлетворить этому требованию. Мы выделили ее на отдельную строку, чтобы сделать ее более заметной. Прежде чем мы распростимся с программой подсчета симво- лов, отметим, что если файл ввода не содержит никаких симво- лов, то условие в WHILE или FOR не выполнится при самом пер- вом обращении к GETCHAR , и, следовательно , программа вы- даст нуль, т.е. Правильный ответ. это важное замечание. од- ним из приятных свойств операторов WHILE и FOR является то, что они проверяют условие в начале цикла, т.е. До выполнения тела. Если делать ничего не надо, то ничего не будет сдела- но, даже если это означает, что тело цикла никогда не будет выполняться. программы должны действовать разумно, когда они обращаются с файлами типа "никаких символов". Операторы WHILE и FOR помогают обеспечить правильное поведение прог- рамм при граничных значениях проверяемых условий. 1.5.4. Подсчет строк Следующая программа подсчитывает количество строк в файле ввода. Предполагается, что строки ввода заканчиваются символом новой строки \N, скрупулезно добавленным к каждой выписанной строке. MAIN() /* COUNT LINES IN INPUT */ { INT C,NL; NL = 0; WHILE ((C = GETCHAR()) != EOF) IF (C =='\N') ++NL; PRINTF("%D\N", NL); } Тело WHILE теперь содержит оператор IF , который в свою очередь управляет оператором увеличения ++NL. Оператор IF проверяет заключенное в круглые скобки условие и, если оно истинно, выполняет следующий за ним оператор /или группу операторов, заключенных в фигурные скобки/. Мы опять исполь- зовали сдвиг вправо, чтобы показать, что чем управляет. Удвоенный знак равенства == является обозначением в языке "C" для "равно" /аналогично .EQ. В фортране/. Этот символ введен для того, чтобы отличать проверку на равенство от одиночного =, используемого при присваивании. Поскольку в типичных "C" - программах знак присваивания встречается при- мерно в два раза чаще, чем проверка на равенство, то естест- венно, чтобы знак оператора был вполовину короче. Любой отдельный символ может быть записан внутри оди- ночных кавычек, и при этом ему соответствует значение, рав- ное численному значению этого символа в машинном наборе сим- волов; это называется символьной константой. Так, например, 'A' - символьная константа; ее значение в наборе символов ASCII /американский стандартный код для обмена информацией/ равно 65, внутреннему представлению символа а. Конечно, 'A' предпочтительнее, чем 65: его смысл очевиден и он не зависит от конкретного машинного набора символов. Условные последовательности, используемые в символьных строках, также занимают законное место среди символьных кон- стант. Так в проверках и арифметических выражениях '\N' представляет значение символа новой строки. Вы должны твердо уяснить, что '\N' - отдельный символ, который в выражениях эквивалентен одиночному целому; с другой стороны "\N" - это символьная строка, которая содержит только один символ. Воп- рос о сопоставлении строк и символов обсуждается в главе 2. Упражнение 1-6 ---------------- Напишите программу для подсчета пробелов, табуляций и новых строк. Упражнение 1-7 ---------------- Напишите программу, которая копирует ввод на вывод, за- меняя при этом каждую последовательность из одного или более пробелов на один пробел. 1.5.5. Подсчет слов Четвертая программа из нашей серии полезных программ подсчитывает количество строк, слов и символов, используя при этом весьма широкое определение, что словом является лю- бая последовательность символов, не содержащая пробелов, та- буляций или новых строк. /Это - упрощенная версия утилиты 'WC' системы 'UNIX'/ #DEFINE YES 1 #DEFINE NO 0 MAIN() /* COUNT LINES, WORDS, CHARS IN INPUT */ { INT C, NL, NW, INWORD; INWORD = NO; NL = NW = NC = 0; WHILE((C = GETCHAR()) != EOF) { ++NC; IF (C == '\N') ++NL; IF (C==' ' \!\! C=='\N' \!\! C=='\T') INWORD = NO; ELSE IF (INWORD == NO) { INWORD = YES; ++NW; } } PRINTF("%D %D %D\N", NL, NW, NC); } Каждый раз, когда программа встречает первый символ слова, она увеличивает счетчик числа слов на единицу. Пере- менная INWORD следит за тем, находится ли программа в насто- ящий момент внутри слова или нет; сначала этой переменной присваивается " не в слове", чему соответствует значение NO. Мы предпочитаем символические константы YES и NO литерным значениям 1 и 0, потому что они делают программу более удоб- ной для чтения. Конечно, в такой крошечной программе, как эта, это не приводит к заметной разнице, но в больших прог- раммах увеличение ясности вполне стоит тех скромных дополни- тельных усилий, которых требует следование этому принципу с самого начала. Вы также обнаружите, что существенные измене- ния гораздо легче вносить в те программы, где числа фигури- руют только в качестве символьных констант. Строка NL = NW = NC = 0; полагает все три переменные равными нулю. Это не особый случай, а следствие того обстоятельства, что операто- ру присваивания соответствует некоторое значение и присваи- вания проводятся последовательно справа налево. Таким обра- зом, дело обстоит так, как если бы мы написали NC = (NL = (NW = 0)); операция \!\! Означает OR , так что строка IF( C==' ' \!\! C=='\N' \!\! C=='\T') говорит "если с - пробел, или с - символ новой строки, или с -табуляция ..."./условная последовательность \T является изображением символа табуляции/. Имеется соответствующая операция && для AND. Выражения, связанные операциями && или \!\! , Рассматриваются слева на право, и при этом гарантируется, что оценивание выражений будет прекращено, как только станет ясно, является ли все выражение истинным или ложным. Так, если 'C' оказывается пробелом, то нет никакой необходимости проверять, является ли 'C' символом новой строки или табуляции, и такие проверки действительно не делаются. В данном случае это не имеет принципиального значения, но, как мы скоро увидим, в более сложных ситуациях эта особенность языка весьма существенна. Этот пример также демонстрирует оператор ELSE языка "C", который указывает то действие, которое должно выполняться, если условие, содержащееся в операторе IF, окажется ложным. Общая форма такова: IF (выражение) оператор-1 ELSE оператор-2 Выполняется один и только один из двух операторов, свя- занных с конструкцией IF-ELSE. Если выражение истинно, вы- полняется оператор-1; если нет - выполняется оператор-2. Фактически каждый оператор может быть довольно сложным. В программе подсчета слов оператор, следующий за ELSE , явля- ется опертором IF , который управляет двумя операторами в фигурных скобках. Упражнение 1-9 ---------------- Как бы вы стали проверять программу подсчета слов ? Kакие имеются ограничения ? Упражнение 1-10 ----------------- Напишите программу, которая будет печатать слова из фай- ла ввода, причем по одному на строку. Упражнение 1-11 ---------------- Переделайте программу подсчета слов, используя лучшее пределение "слова"; считайте, например словом последователь- ность букв, цифр и апострофов, рачинающуюся с буквы. 1.6. Массивы Давайте напишем программу подсчета числа появлений каж- дой цифры, символов пустых промежутков/пробел, табуляции, новая строка/ и всех остальных символов. Конечно, такая за- дача несколько искусственна, но она позволит нам проиллюст- рировать в одной программе сразу несколько аспектов языка "C". Мы разбили вводимые символы на двенадцать категорий, и нам удобнее использовать массив для хранения числа появлений каждой цифры, а не десять отдельных переменных. Вот один из вариантов программы: MAIN() /* COUNT DIGITS, WHITE SPACE, OTHERS */ { INT C, I, NWHITE, NOTHER; INT NDIGIT[10]; NWHITE = NOTHER = 0; FOR (I = 0; I < 10; ++I) NDIGIT[I] = 0; WHILE ((C = GETCHAR()) != EOF) IF (C >= '0' && C <= '9') ++NDIGIT[C-'0']; ELSE IF(C== ' ' \!\! C== '\N' \!\! C== '\T') ++NWHITE; ELSE ++NOTHER; PRINTF("DIGITS ="); FOR (I = 0; I < 10; ++I) PRINTF(" %D", NDIGIT[I]); PRINTF("\NWHITE SPACE = %D, OTHER = %D\N", NWHITE, NOTHER); } Описание INT NDIGIT[10]; объявляет, что NDIGIT является массивом из десяти целых. в языке "C" индексы массива всегда начинаются с нуля /а не с 1, как в фортране или PL/1/, так что элементами массива яв- ляются NDIGIT[0], NDIGIT[1],..., NDIGIT[9]. эта особенность отражена в циклах FOR , которые инициализируют и печатают массив. Индекс может быть любым целым выражением, которое, ко- нечно, может включать целые переменные, такие как I , и це- лые константы. Эта конкретная программа сильно опирается на свойства символьного представления цифр. Так, например, в программе проверка IF( C >= '0' && C <= '9')... определяет, является ли символ в 'C' цифрой, и если это так, то численное значение этой цифры определяется по формуле / C - '0'/. Такой способ работает только в том случае, если зна- чения символьных констант '0', '1' и т.д. Положительны, рас- положены в порядке возрастания и нет ничего, кроме цифр, между константами '0' и '9'. К счастью, это верно для всех общепринятых наборов символов. По определению перед проведением арифметических опера- ций, вовлекающих переменные типа CHAR и INT, все они преоб- разуются к типу INT, TAK что в арифметических выражениях пе- ременные типа CHAR по существу идентичны переменным типа INT. Это вполне естественно и удобно; например, C -'0'- это целое выражение со значением между 0 и 9 в соответствии с тем, какой символ от '0' до '9' хранится в 'C', и, следова- тельно, оно является подходящим индексом для массива NDIGIT. Выяснение вопроса, является ли данный символ цифрой, символом пустого промежутка или чем-либо еще, осуществляется последовательностью операторов IF (C >= '0' && C <= '9') ++NDIGIT[C-'0']; ELSE IF(C == ' ' \!\! C == '\N' \!\! C == '\T') ++NWHITE; ELSE ++NOTHER; Конструкция IF (условие) оператор ELSE IF (условие) оператор ELSE оператор часто встречаются в программах как средство выражения ситуа- ций, в которых осуществляется выбор одного из нескольких возможных решений. Программа просто движется сверху вниз до тех пор, пока не удовлетворится какое-нибудь условие; тогда выполняется соответствующий 'оператор', и вся конструкция завершается. /Конечно, 'оператор' может состоять из нескольких операто- ров, заключенных в фигурные скобки/. Если ни одно из условий не удовлетворяется, то выполняется 'оператор', стоящий после заключительного ELSE, если оно присутствует. Если последнеE ELSE и соответствующий 'оператор' опущены (как в программе подсчета слов), то никаких действий не производится. Между начальным IF и конечным ELSE может помещаться произвольное количество групп ELSE IF (условие) оператор С точки зрения стиля целесообразно записывать эту конст- рукцию так, как мы показали, с тем чтобы длинные выражения не залезали за правый край страницы. Оператор SWITCH (переключатель), который рассматривается в главе 3, представляет другую возможность для записи раз- ветвления на несколько вариантов. этот оператор особенно удобен, когда проверяемое выражение является либо просто не- которым целым, либо символьным выражением, совпадающим с од- ной из некоторого набора констант. Версия этой программы, использующая оператор SWITCH, будет для сравнения приведена в главе 3. Упражнение 1-12 ---------------- Напишите программу, печатающую гистограмму длин слов из файла ввода. Самое легкое - начертить гистограмму горизон- тально; вертикальная ориентация требует больших усилий. 1.7. Функции В языке "C" функции эквивалентны подпрограммам или функ- циям в фортране или процедурам в PL/1, паскале и т.д. Функ- ции дают удобный способ заключения некоторой части вычисле- ний в черный ящик, который в дальнейшем можно использовать, не интересуясь его внутренним содержанием. Использование функций является фактически единственным способом справиться с потенциальной сложностью больших программ. Если функции организованы должным образом, то можно игнорировать то, как делается работа; достаточно знание того, что делается. Язык "C" разработан таким образом, чтобы сделать использование функций легким, удобным и эффективным. Вам будут часто вст- речаться функции длиной всего в несколько строчек, вызывае- мые только один раз, и они используются только потому, что это проясняет некоторую часть программы. До сих пор мы использовали только предоставленные нам функции типа PRINTF, GETCHAR и PUTCHAR; теперь пора написать несколько наших собственных. так как в "C" нет операции воз- ведения в степень, подобной операции ** в фортране или PL/1, давайте проиллюстрируем механику определения функции на при- мере функции POWER(M,N), возводящей целое м в целую положи- тельную степень N. Так значение POWER(2,5) равно 32. Конеч- но, эта функция не выполняет всей работы операции **, пос- кольку она действует только с положительными степенями не- больших чисел, но лучше не создавать дополнительных затруд- нений, смешивая несколько различных вопросов. Ниже приводится функция POWER и использующая ее основная программа, так что вы можете видеть целиком всю структуру. MAIN() /* TEST POWER FUNCTION */ { INT I; FOR(I = 0; I < 10; ++I) PRINTF("%D %D %D\N",I,POWER(2,I),POWER(-3,I)); } POWER(X,N) /* RAISE X N-TH POWER; N > 0 */ INT X,N; { INT I, P; P = 1; FOR (I =1; I <= N; ++I) P = P * X; RETURN (P); } Все функции имеют одинаковый вид: имя (список аргументов, если они имеются) описание аргументов, если они имеются { описания операторы } Эти функции могут быть записаны в любом порядке и нахо- диться в одном или двух исходных файлах. Конечно, если ис- ходная программа размещается в двух файлах, вам придется дать больше указаний при компиляции и загрузке, чем если бы она находилась в одном, но это дело операционной системы, а не атрибут языка. В данный момент, для того чтобы все полу- ченные сведения о прогоне "C"- программ, не изменились в дальнейшем, мы будем предполагать, что обе функции находятся в одном и том же файле. Функция POWER вызывается дважды в строке PRINTF("%D %D %D\N",I,POWER(2,I),POWER(-3,I)); при каждом обращении функция POWER, получив два аргумента, вазвращает целое значение, которое печатается в заданном формате. В выражениях POWER(2,I) является точно таким же це- лым, как 2 и I. /Не все функции выдают целое значение; мы займемся этим вопросом в главе 4/. Аргументы функции POWER должны быть описаны соответству- ющим образом, так как их типы известны. Это сделано в строке INT X,N; которая следует за именем функции. Описания аргументов помещаются между списком аргументов и открывающейся левой фигурной скобкой; каждое описание за- канчивается точкой с запятой. Имена, использованные для ар- гументов функции POWER, являются чисто локальными и недос- тупны никаким другим функциям: другие процедуры могут ис- пользовать те же самые имена без возникновения конфликта. Это верно и для переменных I и P; I в функции POWER никак не связано с I в функции MAIN. Значение, вычисленное функцией POWER, передаются в MAIN с помощью оператора RETURN, точно такого же, как в PL/1. внутри круглых скобок можно написать любое выражение. Функ- ция не обязана возвращать какое-либо значение; оператор RETURN, не содержащий никакого выражения, приводит к такой же передаче управления, как "сваливание на конец" функции при достижении конечной правой фигурной скобки, но при этом в вызывающую функцию не возвращается никакого полезного зна- чения. Упражнение 1-13 ---------------- Апишите программу преобразования прописных букв из айла ввода в строчные, используя при этом функцию OWER(C), кото- рая возвращает значение 'C', если C'- не буква, и значение соответствующей строчной уквы, если 'C'-буква. 1.8. Аргументы - вызов по значению Один аспект в "C" может оказаться непривычным для прог- раммистов, которые использовали другие языки, в частности, фортран и PL/1. в языке "C" все аргументы функций передаются "по значению". это означает, что вызванная функция получает значения своих аргументов с помощью временных переменных /фактически через стек/, а не их адреса. Это приводит к не- которым особенностям, отличным от тех, с которыми мы сталки- вались в языках типа фортрана и PL/1, использующих "вызов по ссылке ", где вызванная процедура работает с адресом аргу- мента, а не с его значением. Главное отличие состоит в том, что в "C" вызванная функ- ция не может изменить переменную из вызывающей функции; она может менять только свою собственную временную копию. Вызов по значению, однако, не помеха, а весьма ценное качество. Оно обычно приводит к более компактным программам, содержащим меньше не относящихся к делу переменных, потому что с аргументами можно обращаться как с удобно инициализи- рованными локальными перемнными вызванной процедуры. Вот, например, вариант функции POWER использующей это обстоятель- ство POWER(X,N) /* RAISE X N-TH POWER; N > 0; VERSION 2 */ INT X,N; { INT P; FOR (P = 1; N > 0; --N) P = P * X; RETURN (P); } Аргумент N используется как временная переменная; из не- го вычитается единица до тех пор, пока он не станет нулем. Переменная I здесь больше не нужна. чтобы ни происходило с N внутри POWER это никак не влияет на аргумент, с которым пер- воначально обратились к функции POWER. При необходимости все же можно добиться, чтобы функция изменила переменную из вызывающей программы. Эта программа должна обеспечить установление адреса переменной /техничес- ки, через указатель на переменную/, а в вызываемой функции надо описать соответствующий аргумент как указатель и ссы- латься к фактической переменной косвенно через него. Мы рас- смотрим это подробно в главе 5. Когда в качестве аргумента выступает имя массива, то фактическим значением, передаваемым функции, является адрес начала массива. /Здесь нет никакого копирования элементов массива/. С помощью индексации и адреса начала функция может найти и изменить любой элемент массива. Это - тема следующе- го раздела. 1.9. Массивы символов По-видимому самым общим типом массива в "C" является массив символов. Чтобы проиллюстрировать использование мас- сивов символов и обрабатывающих их функций, давайте напишем программу, которая читает набор строк и печатает самую длин- ную из них. Основная схема программы достаточно проста: WHILE (имеется еще строка) IF (эта строка длиннее самой длинной из предыдущих) запомнить эту строку и ее длину напечатать самую длинную строку По этой схеме ясно, что программа естественным образом распадается на несколько частей. Одна часть читает новую строку, другая проверяет ее, третья запоминает, а остальные части программы управляют этим процессом. Поскольку все так прекрасно делится, было бы хорошо и написать программу соответсвующим образом. Давайте сначала напишем отдельную функцию GETLINE, которая будет извлекать следующую строку из файла ввода; это - обобщение функции GETCHAR. мы попытаемся сделать эту функцию по возможности более гибкой, чтобы она была полезной и в других ситуациях. Как минимум GETLINE должна передавать сигнал о возможном по- явлении конца файла; более общий полезный вариант мог бы пе- редавать длину строки или нуль, если встретится конец файла. нуль не может быть длиной строки, так как каждая строка со- держит по крайней мере один символ; даже строка, содержащая только символ новой строки, имеет длину 1. Когда мы находим строку, которая длиннее самой длинной из предыдущих, то ее надо где-то запомнить. Это наводит на мысль о другой функции, COPY , которая будет копировать но- вую строку в место хранения. Наконец, нам нужна основная программа для управления функциями GETLINE и COPY . Вот результат : #DEFINE MAXLINE 1000 /* MAXIMUM INPUT LINE SIZE */ MAIN() /* FIND LONGEST LINE */ { INT LEN; /* CURRENT LINE LENGTH */ INT MAX; /* MAXIMUM LENGTH SEEN SO FAR */ CHAR LINE[MAXLINE]; /* CURRENT INPUT LINE */ CHAR SAVE[MAXLINE]; /* LONGEST LINE, SAVED */ MAX = 0; WHILE ((LEN = GETLINE(LINE, MAXLINE)) > 0) IF (LEN > MAX) { MAX = LEN; COPY(LINE, SAVE); } IF (MAX > 0) /* THERE WAS A LINE */ PRINTF("%S", SAVE); } GETLINE(S,LIM) /* GET LINE INTO S,RETURN LENGTH */ CHAR S[]; INT LIM; { INT C, I; FOR(I=0;I<LIM-1 && (C=GETCHAR())!=EOF && C!='\N';++I) S[I] = C; IF (C == '\N') { S[I] = C; ++I; } S[I] = '\0'; RETURN(I); } COPY(S1, S2) /* COPY S1 TO S2; ASSUME S2 BIG ENOUGH */ CHAR S1[], S2[]; { INT I; I = 0; WHILE ((S2[I] = S1[I] != '\0') ++I; } Функция MAIN и GETLINE общаются как через пару аргумен- тов, так и через возвращаемое значение. аргументы GETLINE описаны в строках CHAR S[]; INT LIM; которые указывают, что первый аргумент является массивом, а второй - целым. Длина массива S не указана, так как она определена в MAIN . функция GETLINE использует оператор RETURN для пере- дачи значения назад в вызывающую программу точно так же, как это делала функция POWER. Одни функции возвращают некоторое нужное значение; другие, подобно COPY, используются из-за их действия и не возвращают никакого значения. Чтобы пометить конец строки символов, функция GETLINE помещает в конец создаваемого ей массива символ \0 /нулевой символ, значение которого равно нулю/. Это соглашение ис- пользуется также компилятором с языка "C": когда в "C" - программе встречается строчная константа типа "HELLO\N" то компилятор создает массив символов, содержащий символы этой строки, и заканчивает его символом \0, с тем чтобы фун- кции, подобные PRINTF, могли зафиксировать конец массива: ------------------------------------------- ! H ! E ! L ! L ! O ! \N ! \0 ! ------------------------------------------- Спецификация формата %S указывает, что PRINTF ожидает стро- ку, представленную в такой форме. Проанализировав функцию COPY, вы обнаружите, что и она опирается на тот факт, что ее входной аргумент оканчивается символом \0, и копирует этот символ в выходной аргумент S2. /Все это подразумевает, что символ \0 не является частью нормального текста/. Между прочим, стоит отметить, что даже в такой маленькой программе, как эта, возникает несколько неприятных организа- ционных проблем. Например, что должна делать MAIN, если она встретит строку, превышающую ее максимально возможный раз- мер? Функция GETLINE поступает разумно: при заполнении мас- сива она прекращает дальнейшее извлечение символов, даже ес- ли не встречает символа новой строки. Проверив полученную длину и последний символ, функция MAIN может установить, не была ли эта строка слишком длинной, и поступить затем, как она сочтет нужным. Ради краткости мы опустили эту проблему. Пользователь функции GETLINE никак не может заранее уз- нать, насколько длинной окажется вводимая строка. Поэтому в GETLINE включен контроль переполнения. в то же время пользо- ватель функции COPY уже знает /или может узнать/, каков раз- мер строк, так что мы предпочли не включать в эту функцию дополнительный контроль. Упражнение 1-14 ----------------- Переделайте ведущую часть программы поиска самой длинной строки таким образом, чтобы она правильно печатала длины сколь угодно длинных вводимых строк и возможно больший текст. Упражнение 1-15 ----------------- Напишите программу печати всех строк длиннее 80 симво- лов. Упражнение 1-16 ----------------- Напишите программу, которая будет удалять из каждой строки стоящие в конце пробелы и табуляции, а также строки, целиком состоящие из пробелов. Упражнение 1-17 ----------------- Напишите функцию REVERSE(S), которая распологает сим- вольную строку S в обратном порядке. С ее помощью напишите программу, которая обратит каждую строку из файла ввода. 1.10. Область действия: внешние переменные Переменные в MAIN(LINE, SAVE и т.д.) являются внутренни- ми или локальными по отношению к функции MAIN, потому что они описаны внутри MAIN и никакая другая функция не имеет к ним прямого доступа. Это же верно и относительно переменных в других функциях; например, переменная I в функции GETLINE никак не связана с I в COPY. Каждая локальная переменная су- ществует только тогда, когда произошло обращение к соответс- твующей функции, и исчезает, как только закончится выполне- ние этой функции. По этой причине такие переменные, следуя терминологии других языков, обычно называют автоматическими. Мы впредь будем использовать термин автоматические при ссыл- ке на эти динамические локальные переменные. /в главе 4 об- суждается класс статической памяти, когда локальные перемен- ные все же оказываются в состоянии сохранить свои значения между обращениями к функциям/. Поскольку автоматические переменные появляются и исчеза- ют вместе с обращением к функции, они не сохраняют своих значений в промежутке от одного вызова до другого, в силу чего им при каждом входе нужно явно присваивать значения. Если этого не сделать, то они будут содержать мусор. В качестве альтернативы к автоматическим переменным мож- но определить переменные, которые будут внешними для всех функций, т.е. Глобальными переменными, к которым может обра- титься по имени любая функция, которая пожелает это сделать. (этот механизм весьма сходен с "COMMON" в фортране и "EXTERNAL" в PL/1). Так как внешние переменные доступны всю- ду, их можно использовать вместо списка аргументов для пере- дачи данных между функциями. Кроме того, поскольку внешние переменные существуют постоянно, а не появляются и исчезают вместе с вызываемыми функциями, они сохраняют свои значения и после того, как функции, присвоившие им эти значения, за- вершат свою работу. Внешняя переменная должна быть определена вне всех функ- ций; при этом ей выделяется фактическое место в памяти. Та- кая переменная должна быть также описана в каждой функции, которая собирается ее использовать; это можно сделать либо явным описанием EXTERN, либо неявным по контексту. Чтобы сделать обсуждение более конкретным, давайте перепишем прог- рамму поиска самой длинной строки, сделав LINE, SAVE и MAX внешними переменными. Это потребует изменения описаний и тел всех трех функций, а также обращений к ним. #DE