I) N = 10 * N + S[I] - '0'; RETURN(N); } KAK Уже обсуждалось в главе 1, выражение S[I] - '0' имеет численное значение находящегося в S[I] символа, потому что значение символов '0', '1' и т.д. образуют возрастающую последовательность расположенных подряд целых положительных чисел. Другой пример преобразования CHAR в INT дает функция LOWER, преобразующая данную прописную букву в строчную. Если выступающий в качестве аргумента символ не является пропис- ной буквой, то LOWER возвращает его неизменным. Приводимая ниже программа справедлива только для набора символов ASCII. LOWER(C) /* CONVERT C TO LOWER CASE; ASCII ONLY */ INT C; { IF ( C >= 'A' && C <= 'Z' ) RETURN( C + '@' - 'A'); ELSE /*@ Записано вместо 'A' строчного*/ RETURN(C); } Эта функция правильно работает при коде ASCII, потому что численные значения, соответствующие в этом коде прописным и строчным буквам, отличаются на постоянную величину, а каждый алфавит является сплошным - между а и Z нет ничего, кроме букв. Это последнее замечание для набора символов EBCDIC систем IBM 360/370 оказывается несправедливым, в силу чего эта программа на таких системах работает неправильно - она преобразует не только буквы. При преобразовании символьных переменных в целые возни- кает один тонкий момент. Дело в том, что сам язык не указы- вает, должны ли переменным типа CHAR соответствовать числен- ные значения со знаком или без знака. Может ли при преобра- зовании CHAR в INT получиться отрицательное целое? К сожале- нию, ответ на этот вопрос меняется от машины к машине, отра- жая расхождения в их архитектуре. На некоторых машинах (PDP-11, например) переменная типа CHAR, крайний левый бит которой содержит 1, преобразуется в отрицательное целое ("знаковое расширение"). На других машинах такое преобразо- вание сопровождается добавлением нулей с левого края, в ре- зультате чего всегда получается положительное число. Определение языка "C" гарантирует, что любой символ из стандартного набора символов машины никогда не даст отрица- тельного числа, так что эти символы можно свободно использо- вать в выражениях как положительные величины. Но произволь- ные комбинации двоичных знаков, хранящиеся как символьные переменные на некоторых машинах, могут дать отрицательные значения, а на других положительные. Наиболее типичным примером возникновения такой ситуации является сучай, когда значение -1 используется в качестве EOF. Рассмотрим программу CHAR C; C = GETCHAR(); IF ( C == EOF ) ... На машине, которая не осуществляет знакового расширения, переменная 'с' всегда положительна, поскольку она описана как CHAR, а так как EOF отрицательно, то условие никогда не выполняется. Чтобы избежать такой ситуации, мы всегда пре- дусмотрительно использовали INT вместо CHAR для любой пере- менной, получающей значение от GETCHAR. Основная же причина использования INT вместо CHAR не связана с каким-либо вопросом о возможном знаковом расшире- нии. просто функция GETCHAR должна передавать все возможные символы (чтобы ее можно было использовать для произвольного ввода) и, кроме того, отличающееся значение EOF. Следова- тельно значение EOF не может быть представлено как CHAR, а должно храниться как INT. Другой полезной формой автоматического преобразования типов является то, что выражения отношения, подобные I>J, и логические выражения, связанные операциями && и \!\!, по оп- ределению имеют значение 1, если они истинны, и 0, если они ложны. Таким образом, присваивание ISDIGIT = C >= '0' && C <= '9'; полагает ISDIGIT равным 1, если с - цифра, и равным 0 в про- тивном случае. (В проверочной части операторов IF, WHILE, FOR и т.д. "Истинно" просто означает "не нуль"). Неявные арифметические преобразования работают в основ- ном, как и ожидается. В общих чертах, если операция типа + или *, которая связывает два операнда (бинарная операция), имеет операнды разных типов, то перед выполнением операции "низший" тип преобразуется к "высшему" и получается резуль- тат "высшего" типа. Более точно, к каждой арифметической операции применяется следующая последовательность правил преобразования. - Типы CHAR и SHORT преобразуются в INT, а FLOAT в DOUBLE. - Затем, если один из операндов имеет тип DOUBLE, то другой преобразуется в DOUBLE, и результат имеет тип DOUBLE. - В противном случае, если один из операндов имеет тип LONG, то другой преобразуется в LONG, и результат имеет тип LONG. - В противном случае, если один из операндов имеет тип UNSIGNED, то другой преобразуется в UNSIGNED и результат имеет тип UNSIGNED. - В противном случае операнды должны быть типа INT, и результат имеет тип INT. Подчеркнем, что все переменные типа FLOAT в выражениях пре- образуются в DOUBLE; в "C" вся плавающая арифметика выполня- ется с двойной точностью. Преобразования возникают и при присваиваниях; значение правой части преобразуется к типу левой, который и является типом результата. Символьные переменные преобразуются в це- лые либо со знаковым расширением ,либо без него, как описано выше. Обратное преобразование INT в CHAR ведет себя хорошо - лишние биты высокого порядка просто отбрасываются. Таким об- разом INT I; CHAR C; I = C; C = I; значение 'с' не изменяется. Это верно независимо от того, вовлекается ли знаковое расширение или нет. Если х типа FLOAT, а I типа INT, то как х = I; так и I = х; приводят к преобразованиям; при этом FLOAT преобразуется в INT отбрасыванием дробной части. Тип DOUBLE преобразуется во FLOAT округлением. Длинные целые преобразуются в более ко- роткие целые и в переменные типа CHAR посредством отбрасыва- ния лишних битов высокого порядка. Так как аргумент функции является выражением, то при пе- редаче функциям аргументов также происходит преобразование типов: в частности, CHAR и SHORT становятся INT, а FLOAT становится DOUBLE. Именно поэтому мы описывали аргументы функций как INT и DOUBLE даже тогда, когда обращались к ним с переменными типа CHAR и FLOAT. Наконец, в любом выражении может быть осуществлено ("принуждено") явное преобразование типа с помощью конструк- ции, называемой перевод (CAST). В этой конструкции, имеющей вид (имя типа) выражение Выражение преобразуется к указанному типу по правилам преобразования, изложенным выше. Фактически точный смысл операции перевода можно описать следующим образом: выражение как бы присваивается некоторой переменной указанного типа, которая затем используется вместо всей конструкции. Напри- мер, библиотечная процедура SQRT ожидает аргумента типа DOUBLE и выдаст бессмысленный ответ, если к ней по небреж- ности обратятся с чем-нибудь иным. таким образом, если N - целое, то выражение SQRT((DOUBLE) N) до передачи аргумента функции SQRT преобразует N к типу DOUBLE. (Отметим, что операция перевод преобразует значение N в надлежащий тип; фактическое содержание переменной N при этом не изменяется). Операция перевода имрация перевода име- ет тот же уровень старшинства, что и другие унарные опера- ции, как указывается в таблице в конце этой главы. Упражнение 2-2 --------------- Составьте программу для функции HTOI(S), которая преоб- разует строку шестнадцатеричных цифр в эквивалентное ей це- лое значение. При этом допустимыми цифрами являются цифры от 1 до 9 и буквы от а до F. 2.8. Операции увеличения и уменьшения В языке "C" предусмотрены две необычные операции для увеличения и уменьшения значений переменных. Операция увели- чения ++ добавляет 1 к своему операнду, а операция уменьше- ния -- вычитает 1. Мы часто использовали операцию ++ для увеличения переменных, как, например, в IF(C == '\N') ++I; Необычный аспект заключается в том, что ++ и -- можно использовать либо как префиксные операции (перед переменной, как в ++N), либо как постфиксные (после переменной: N++). Эффект в обоих случаях состоит в увеличении N. Но выражение ++N увеличивает переменную N до использования ее значения, в то время как N++ увеличивает переменную N после того, как ее значение было использовано. Это означает, что в контексте, где используется значение переменной, а не только эффект увеличения, использование ++N и N++ приводит к разным ре- зультатам. Если N = 5, то х = N++; устанавливает х равным 5, а х = ++N; полагает х равным 6. В обоих случаях N становится равным 6. Операции увеличения и уменьшения можно применять только к переменным; выражения типа х=(I+J)++ являются незаконными. В случаях, где нужен только эффект увеличения, а само значение не используется, как, например, в IF ( C == '\N' ) NL++; выбор префиксной или постфиксной операции является делом вкуса. но встречаются ситуации, где нужно использовать имен- но ту или другую операцию. Рассмотрим, например, функцию SQUEEZE(S,C), которая удаляет символ 'с' из строки S, каждый раз, как он встречается. SQUEEZE(S,C) /* DELETE ALL C FROM S */ CHAR S[]; INT C; { INT I, J; FOR ( I = J = 0; S[I] != '\0'; I++) IF ( S[I] != C ) S[J++] = S[I]; S[J] = '\0'; } Каждый раз, как встечается символ, отличный от 'с', он копи- руется в текущую позицию J, и только после этого J увеличи- вается на 1, чтобы быть готовым для поступления следующего символа. Это в точности эквивалентно записи IF ( S[I] != C ) { S[J] = S[I]; J++; } Другой пример подобной конструкции дает функция GETLINE, которую мы запрограммировали в главе 1, где можно заменить IF ( C == '\N' ) { S[I] = C; ++I; } более компактной записью IF ( C == '\N' ) S[I++] = C; В качестве третьего примера рассмотрим функцию STRCAT(S,T), которая приписывает строку т в конец строки S, образуя конкатенацию строк S и т. При этом предполагается, что в S достаточно места для хранения полученной комбинации. STRCAT(S,T) /* CONCATENATE T TO END OF S */ CHAR S[], T[]; /* S MUST BE BIG ENOUGH */ { INT I, J; I = J = 0; WHILE (S[I] != '\0') / *FIND END OF S */ I++; WHILE((S[I++] = T[J++]) != '\0') /*COPY T*/ ; } Tак как из T в S копируется каждый символ, то для подготовки к следующему прохождению цикла постфиксная операция ++ при- меняется к обеим переменным I и J. Упражнение 2-3 --------------- Напишите другой вариант функции SQUEEZE(S1,S2), который удаляет из строки S1 каждый символ, совпадающий с каким-либо символом строки S2. Упражнение 2-4 --------------- Напишите программу для функции ANY(S1,S2), которая нахо- дит место первого появления в строке S1 какого-либо символа из строки S2 и, если строка S1 не содержит символов строки S2, возвращает значение -1. 2.9. Побитовые логические операции В языке предусмотрен ряд операций для работы с битами; эти операции нельзя применять к переменным типа FLOAT или DOUBLE. & Побитовое AND \! Побитовое включающее OR ^ побитовое исключающее OR << сдвиг влево >> сдвиг вправо \^ дополнение (унарная операция) "\" иммитирует вертикальную черту. Побитовая операция AND часто используется для маскирования некоторого множества битов; например, оператор C = N & 0177 передает в 'с' семь младших битов N , полагая остальные рав- ными нулю. Операция 'э' побитового OR используется для вклю- чения битов: C = X э MASK устанавливает на единицу те биты в х , которые равны единице в MASK. Следует быть внимательным и отличать побитовые операции & и 'э' от логических связок && и \!\! , Которые подразуме- вают вычисление значения истинности слева направо. Например, если х=1, а Y=2, то значение х&Y равно нулю , в то время как значение X&&Y равно единице./почему?/ Операции сдвига << и >> осуществляют соответственно сдвиг влево и вправо своего левого операнда на число битовых позиций, задаваемых правым операндом. Таким образом , х<<2 сдвигает х влево на две позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению на 4. Сдвиг вправо величины без знака заполняет освобождающиеся биты на некото- рых машинах, таких как PDP-11, заполняются содержанием зна- кового бита /"арифметический сдвиг"/, а на других - нулем /"логический сдвиг"/. Унарная операция \^ дает дополнение к целому; это озна- чает , что каждый бит со значением 1 получает значение 0 и наоборот. Эта операция обычно оказывается полезной в выраже- ниях типа X & \^077 где последние шесть битов х маскируются нулем. Подчеркнем, что выражение X&\^077 не зависит от длины слова и поэтому предпочтительнее, чем, например, X&0177700, где предполага- ется, что х занимает 16 битов. Такая переносимая форма не требует никаких дополнительных затрат, поскольку \^077 явля- ется константным выражением и, следовательно, обрабатывается во время компиляции. Чтобы проиллюстрировать использование некоторых операций с битами, рассмотрим функцию GETBITS(X,P,N), которая возвра- щает /сдвинутыми к правому краю/ начинающиеся с позиции р поле переменной х длиной N битов. мы предполагаем , что крайний правый бит имеет номер 0, и что N и р - разумно за- данные положительные числа. например, GETBITS(х,4,3) возвра- щает сдвинутыми к правому краю биты, занимающие позиции 4,3 и 2. GETBITS(X,P,N) /* GET N BITS FROM POSITION P */ UNSIGNED X, P, N; { RETURN((X >> (P+1-N)) & \^(\^0 << N)); } Операция X >> (P+1-N) сдвигает желаемое поле в правый конец слова. Описание аргумента X как UNSIGNED гарантирует, что при сдвиге вправо освобождающиеся биты будут заполняться ну- лями, а не содержимым знакового бита, независимо от того, на какой машине пропускается программа. Все биты константного выражения \^0 равны 1; сдвиг его на N позиций влево с по- мощью операции \^0<<N создает маску с нулями в N крайних правых битах и единицами в остальных; дополнение \^ создает маску с единицами в N крайних правых битах. Упражнение 2-5 --------------- Переделайте GETBITS таким образом, чтобы биты отсчитыва- лись слева направо. Упражнение 2-6 --------------- Напишите программу для функции WORDLENGTH(), вычисляющей длину слова используемой машины, т.е. Число битов в перемен- ной типа INT. Функция должна быть переносимой, т.е. Одна и та же исходная программа должна правильно работать на любой машине. Упражнение 2-7 --------------- Напишите программу для функции RIGHTROT(N,B), сдвигающей циклически целое N вправо на B битовых позиций. Упражнение 2-8 --------------- Напишите программу для функции INVERT(X,P,N), которая инвертирует (т.е. Заменяет 1 на 0 и наоборот) N битов X, на- чинающихся с позиции P, оставляя другие биты неизмененными. 2.10. Операции и выражения присваивания Такие выражения, как I = I + 2 в которых левая часть повторяется в правой части могут быть записаны в сжатой форме I += 2 используя операцию присваивания вида +=. Большинству бинарных операций (операций подобных +, ко- торые имеют левый и правый операнд) соответствует операция присваивания вида оп=, где оп - одна из операций + - * / % << >> & \^ \! Если е1 и е2 - выражения, то е1 оп= е2 эквивалентно е1 = (е1) оп (е2) за исключением того, что выражение е1 вычисляется только один раз. Обратите внимание на круглые скобки вокруг е2: X *= Y + 1 то X = X * (Y + 1) не X = X * Y + 1 В качестве примера приведем функцию BITCOUNT, которая подсчитывает число равных 1 битов у целого аргумента. BITCOUNT(N) /* COUNT 1 BITS IN N */ UNSIGNED N; ( INT B; FOR (B = 0; N != 0; N >>= 1) IF (N & 01) B++; RETURN(B); ) Не говоря уже о краткости, такие операторы приваивания имеют то преимущество, что они лучше соответствуют образу человеческого мышления. Мы говорим: "прибавить 2 к I" или "увеличить I на 2", но не "взять I, прибавить 2 и поместить результат опять в I". Итак, I += 2. Кроме того, в громоздких выражениях, подобных YYVAL[YYPV[P3+P4] + YYPV[P1+P2]] += 2 Tакая операция присваивания облегчает понимание программы, так как читатель не должен скрупулезно проверять, являются ли два длинных выражения действительно одинаковыми, или за- думываться, почему они не совпадают. Такая операция присваи- вания может даже помочь компилятору получить более эффектив- ную программу. Мы уже использовали тот факт, что операция присваивания имеет некоторое значение и может входить в выражения; самый типичный пример WHILE ((C = GETCHAR()) != EOF) присваивания, использующие другие операции присваивания (+=, -= и т.д.) также могут входить в выражения, хотя это случа- ется реже. Типом выражения присваивания является тип его левого операнда. Упражнение 2-9 --------------- В двоичной системе счисления операция X&(X-1) обнуляет самый правый равный 1 бит переменной X.(почему?) используйте это замечание для написания более быстрой версии функции BITCOUNT. 2.11. Условные выражения Операторы IF (A > B) Z = A; ELSE Z = B; конечно вычисляют в Z максимум из а и в. Условное выражение, записанное с помощью тернарной операции "?:", предоставляет другую возможность для записи этой и аналогичных конструк- ций. В выражении е1 ? Е2 : е3 сначала вычисляется выражение е1. Если оно отлично от нуля (истинно), то вычисляется выражение е2, которое и становится значением условного выражения. В противном случае вычисляет- ся е3, и оно становится значением условного выражения. Каж- дый раз вычисляется только одно из выражения е2 и е3. Таким образом, чтобы положить Z равным максимуму из а и в, можно написать Z = (A > B) ? A : B; /* Z = MAX(A,B) */ Следует подчеркнуть, что условное выражение действитель- но является выражением и может использоваться точно так же, как любое другое выражение. Если е2 и е3 имеют разные типы, то тип результата определяется по правилам преобразования, рассмотренным ранее в этой главе. например, если F имеет тип FLOAT, а N - тип INT, то выражение (N > 0) ? F : N Имеет тип DOUBLE независимо от того, положительно ли N или нет. Так как уровень старшинства операции ?: очень низок, прямо над присваиванием, то первое выражение в условном вы- ражении можно не заключать в круглые скобки. Однако, мы все же рекомендуем это делать, так как скобки делают условную часть выражения более заметной. Использование условных выражений часто приводит к корот- ким программам. Например, следующий ниже оператор цикла пе- чатает N элементов массива, по 10 в строке, разделяя каждый столбец одним пробелом и заканчивая каждую строку (включая последнюю) одним символом перевода строки. OR (I = 0; I < N; I++) PRINTF("%6D%C",A[I],(I%10==9 \!\! I==N-1) ? '\N' : ' ') Символ перевода строки записывается после каждого десятого элемента и после N-го элемента. За всеми остальными элемен- тами следует один пробел. Хотя, возможно, это выглядит муд- реным, было бы поучительным попытаться записать это, не ис- пользуя условного выражения. Упражнение 2-10 --------------- Перепишите программу для функции LOWER, которая переводит прописные буквы в строчные, используя вместо конструкции IF-ELSE условное выражение. 2.12. Старшинство и порядок вычисления В приводимой ниже таблице сведены правила старшинства и ас- социативности всех операций, включая и те, которые мы еще не обсуждали. Операции, расположенные в одной строке, имеют один и тот же уровень старшинства; строки расположены в по- рядке убывания старшинства. Так, например, операции *, / и % имеют одинаковый уровень старшинства, который выше, чем уро- вень операций + и -. OPERATOR ASSOCIATIVITY () [] -> . LEFT TO RIGHT ! \^ ++ -- - (TYPE) * & SIZEOF RIGHT TO LEFT * / % LEFT TO RIGHT + - LEFT TO RIGHT << >> LEFT TO RIGHT < <= > >= LEFT TO RIGHT == != LEFT TO RIGHT & LEFT TO RIGHT ^ LEFT TO RIGHT \! LEFT TO RIGHT && LEFT TO RIGHT \!\! LEFT TO RIGHT ?: RIGHT TO LEFT = += -= ETC. RIGHT TO LEFT , (CHAPTER 3) LEFT TO RIGHT Операции -> и . Используются для доступа к элементам струк- тур; они будут описаны в главе 6 вместе с SIZEOF (размер объекта). В главе 5 обсуждаются операции * (косвенная адре- сация) и & (адрес). Отметим, что уровень старшинства побитовых логических опера- ций &, ^ и э ниже уровня операций == и !=. Это приводит к тому, что осуществляющие побитовую проверку выражения, по- добные IF ((X & MASK) == 0) ... Для получения правильных результатов должны заключаться в круглые скобки. Как уже отмечалось ранее, выражения, в которые входит одна из ассоциативных и коммутативных операций (*, +, &, ^, э), могут перегруппировываться, даже если они заключены в круглые скобки. В большинстве случаев это не приводит к ка- ким бы то ни было расхождениям; в ситуациях, где такие рас- хождения все же возможны, для обеспечения нужного порядка вычислений можно использовать явные промежуточные перемен- ные. В языке "C", как и в большинстве языков, не фиксируется порядок вычисления операндов в операторе. Например в опера- торе вида X = F() + G(); сначала может быть вычислено F, а потом G, и наоборот; поэ- тому, если либо F, либо G изменяют внешнюю переменную, от которой зависит другой операнд, то значение X может зависеть от порядка вычислений. Для обеспечения нужной последователь- ности промежуточные результаты можно опять запоминать во временных переменных. Подобным же образом не фиксируется порядок вычисления аргументов функции, так что оператор PRINTF("%D %D\N",++N,POWER(2,N)); может давать (и действительно дает) на разных машинах разные результаты в зависимости от того, увеличивается ли N до или после обращения к функции POWER. Правильным решением, конеч- но, является запись ++N; PRINTF("%D %D\N",N,POWER(2,N)); Обращения к функциям, вложенные операции присваивания, операции увеличения и уменьшения приводят к так называемым "побочным эффектам" - некоторые переменные изменяются как побочный результат вычисления выражений. В любом выражении, в котором возникают побочные эффекты, могут существовать очень тонкие зависимости от порядка, в котором определяются входящие в него переменные. примером типичной неудачной си- туации является оператор A[I] = I++; Возникает вопрос, старое или новое значение I служит в ка- честве индекса. Компилятор может поступать разными способами и в зависимости от своей интерпретации выдавать разные ре- зультаты. Тот случай, когда происходят побочные эффекты (присваивание фактическим переменным), - оставляется на ус- мотрение компилятора, так как наилучший порядок сильно зави- сит от архитектуры машины. Из этих рассуждений вытекает такая мораль: написание программ, зависящих от порядка вычислений, является плохим методом программирования на любом языке. Конечно, необходимо знать, чего следует избегать, но если вы не в курсе, как не- которые вещи реализованы на разных машинах, это неведение может предохранить вас от неприятностей. (Отладочная прог- рамма LINT укажет большинство мест, зависящих от порядка вы- числений.  * 3. Поток управления *  Управляющие операторы языка определяют порядок вычисле- ний. В приведенных ранее примерах мы уже встречались с наи- более употребительными управляющими конструкциями языка "C"; здесь мы опишем остальные операторы управления и уточним действия операторов, обсуждавшихся ранее. 3.1. Операторы и блоки Такие выражения, как X=0, или I++, или PRINTF(...), становятся операторами, если за ними следует точка с запя- той, как, например, X = 0; I++; PRINTF(...); В языке "C" точка с запятой является признаком конца опера- тора, а не разделителем операторов, как в языках типа алго- ла. Фигурные скобки /( и /) используются для объединения описаний и операторов в составной оператор или блок, так что они оказываются синтаксически эквивалентны одному оператору. Один явный пример такого типа дают фигурные скобки, в кото- рые заключаются операторы, составляющие функцию, другой - фигурные скобки вокруг группы операторов в конструкциях IF, ELSE, WHILE и FOR.(на самом деле переменные могут быть опи- саны внутри любого блока; мы поговорим об этом в главе 4). Точка с запятой никогда не ставится после первой фигурной скобки, которая завершает блок. 3.2. IF - ELSE Оператор IF - ELSE используется при необходимости сде- лать выбор. Формально синтаксис имеет вид IF (выражение) оператор-1 ELSE оператор-2, Где часть ELSE является необязательной. Сначала вычисля- ется выражение; если оно "истинно" /т.е. значение выражения отлично от нуля/, то выполняется оператор-1. Если оно ложно /значение выражения равно нулю/, и если есть часть с ELSE, то вместо оператора-1 выполняется оператор-2. Так как IF просто проверяет численное значение выраже- ния, то возможно некоторое сокращение записи. Самой очевид- ной возможностью является запись IF (выражение) вместо IF (выражение !=0) иногда такая запись является ясной и естественной, но време- нами она становится загадочной. То, что часть ELSE в конструкции IF - ELSE является нео- бязательной, приводит к двусмысленности в случае, когда ELSE опускается во вложенной последовательности операторов IF. Эта неоднозначность разрешается обычным образом - ELSE свя- зывается с ближайшим предыдущим IF, не содержащим ELSE. Например, в IF ( N > 0 ) IF( A > B ) Z = A; ELSE Z = B; конструкция ELSE относится к внутреннему IF, как мы и пока- зали, сдвинув ELSE под соответствующий IF. Если это не то, что вы хотите, то для получения нужного соответствия необхо- димо использовать фигурные скобки: IF (N > 0) { IF (A > B) Z = A; } ELSE Z = B; Tакая двусмысленность особенно пагубна в ситуациях типа IF (N > 0) FOR (I = 0; I < N; I++) IF (S[I] > 0) { PRINTF("..."); RETURN(I); } ELSE /* WRONG */ PRINTF("ERROR - N IS ZERO\N"); Запись ELSE под IF ясно показывает, чего вы хотите, но ком- пилятор не получит соответствующего указания и свяжет ELSE с внутренним IF. Ошибки такого рода очень трудно обнаруживают- ся. Между прочим, обратите внимание, что в IF (A > B) Z = A; ELSE Z = B; после Z=A стоит точка с запятой. Дело в том, что согласно грамматическим правилам за IF должен следовать оператор, а выражение типа Z=A, являющееся оператором, всегда заканчива- ется точкой с запятой. 3.3. ELSE - IF Конструкция IF (выражение) оператор ELSE IF (выражение) оператор ELSE IF (выражение) оператор ELSE оператор встречается настолько часто, что заслуживает отдельного краткого рассмотрения. Такая последовательность операторов IF является наиболее распространенным способом программиро- вания выбора из нескольких возможных вариантов. выражения просматриваются последовательно; если какое-то выражение оказывается истинным,то выполняется относящийся к нему опе- ратор, и этим вся цепочка заканчивается. Каждый оператор мо- жет быть либо отдельным оператором, либо группой операторов в фигурных скобках. Последняя часть с ELSE имеет дело со случаем, когда ни одно из проверяемых условий не выполняется. Иногда при этом не надо предпринимать никаких явных действий; в этом случае хвост ELSE оператор может быть опущен, или его можно использовать для контроля, чтобы засечь "невозможное" условие. Для иллюстрации выбора из трех возможных вариантов при- ведем программу функции, которая методом половинного деления определяет, находится ли данное значение х в отсортированном массиве V. Элементы массива V должны быть расположены в по- рядке возрастания. Функция возвращает номер позиции (число между 0 и N-1), в которой значение х находится в V, и -1, если х не содержится в V. BINARY(X, V, N) /* FIND X IN V[0]...V[N-1] */ INT X, V[], N; { INT LOW, HIGH, MID; LOW = 0; HIGH = N - 1; WHILE (LOW <= HIGH) { MID = (LOW + HIGH) / 2; IF (X < V[MID]) HIGH = MID - 1; ELSE IF (X > V[MID]) LOW = MID + 1; ELSE /* FOUND MATCH */ RETURN(MID); } RETURN(-1); } Основной частью каждого шага алгоритма является провер- ка, будет ли х меньше, больше или равен среднему элементу V[MID]; использование конструкции ELSE - IF здесь вполне ес- тественно. 3.4. Переключатель Оператор SWITCH дает специальный способ выбора одного из многих вариантов, который заключается в проверке совпадения значения данного выражения с одной из заданных констант и соответствующем ветвлении. В главе 1 мы привели программу подсчета числа вхождений каждой цифры, символов пустых про- межутков и всех остальных символов, использующую последова- тельность IF...ELSE IF...ELSE. Вот та же самая программа с переключателем. MAIN() /* COUNT DIGITS,WHITE SPACE, OTHERS */ { INT C, I, NWHITE, NOTHER, NDIGIT[10]; NWHITE = NOTHER = 0; FOR (I = 0; I < 10; I++) NDIGIT[I] = 0; WHILE ((C = GETCHAR()) != EOF) SWITCH (C) { CASE '0': CASE '1': CASE '2': CASE '3': CASE '4': CASE '5': CASE '6': CASE '7': CASE '8': CASE '9': NDIGIT[C-'0']++; BREAK; CASE ' ': CASE '\N': CASE '\T': NWHITE++; BREAK; DEFAULT : NOTHER++; BREAK; } PRINTF("DIGITS ="); FOR (I = 0; I < 10; I++) PRINTF(" %D", NDIGIT[I]); PRINTF("\NWHITE SPACE = %D, OTHER = %D\N", NWHITE, NOTHER); Переключатель вычисляет целое выражение в круглых скоб- ках (в данной программе - значение символа с) и сравнивает его значение со всеми случаями (CASE). Каждый случай должен быть помечен либо целым, либо символьной константой, либо константным выражением. Если значение константного выраже- ния, стоящего после вариантного префикса CASE, совпадает со значением целого выражения, то выполнение начинается с этого случая. Если ни один из случаев не подходит, то выполняется оператор после префикса DEFAULT. Префикс DEFAULT является необязательным ,если его нет, и ни один из случаев не подхо- дит, то вообще никакие действия не выполняются. Случаи и вы- бор по умолчанию могут располагаться в любом порядке. Все случаи должны быть различными. Оператор BREAK приводит к немедленному выходу из перек- лючателя. Поскольку случаи служат только в качестве меток, то если вы не предпримите явных действий после выполнения операторов, соответствующих одному случаю, вы провалитесь на следующий случай. Операторы BREAK и RETURN являются самым обычным способом выхода из переключателя. Как мы обсудим позже в этой главе, оператор BREAк можно использовать и для немедленного выхода из операторов цикла WHILE, FOR и DO. Проваливание сквозь случаи имеет как свои достоинства, так и недостатки. К положительным качествам можно отнести то, что оно позволяет связать несколько случаев с одним дей- ствием, как было с пробелом, табуляцией и новой строкой в нашем примере. Но в то же время оно обычно приводит к необ- ходимости заканчивать каждый случай оператором BREAK, чтобы избежать перехода к следующему случаю. Проваливание с одного случая на другой обычно бывает неустойчивым, так как оно склонно к расщеплению при модификации программы. За исключе- нием, когда одному вычислению соответствуют несколько меток, проваливание следует использовать умеренно. Заведите привычку ставить оператор BREAK после последне- го случая (в данном примере после DEFAULT), даже если это не является логически необходимым. В один прекрасный день, ког- да вы добавите в конец еще один случай, эта маленькая мера предосторожности избавит вас от неприятностей. Упражнение 3-1 -------------- Напишите программу для функции EXPAND(S, T), которая ко- пирует строку S в т, заменяя при этом символы табуляции и новой строки на видимые условные последовательности, как \N и \т. используйте переключатель. 3.5. Циклы - WHILE и FOR Мы уже сталкивались с операторами цикла WHILE и FOR. В конструкции WHILE (выражение) оператор вычисляется выражение. Если его значение отлично от нуля, то выполняется оператор и выражение вычисляется снова. Этот цикл продолжается до тех пор, пока значение выражения не станет нулем, после чего выполнение программы продолжается с места после оператора. Оператор FOR (выражение 1; выражение 2; выражение 3) оператор эквивалентен последовательности выражение 1; WHILE (выражение 2) { оператор выражение 3; } Грамматически все три компонента в FOR являются выражениями. наиболее распространенным является случай, когда выражение 1 и выражение 3 являются присваиваниями или обращениями к фун- кциям, а выражение 2 - условным выражением. любая из трех частей может быть опущена, хотя точки с запятой при этом должны оставаться. Если отсутствует выражение 1 или выраже- ние 3, то оно просто выпадает из расширения. Если же отсутс- твует проверка, выражение 2, то считается, как будто оно всегда истинно, так что FOR (;;) { ... } является бесконечным циклом, о котором предполагается, что он будет прерван другими средствами (такими как BREAK или RETURN). Использовать ли WHILE или FOR - это, в основном дело вкуса. Например в WHILE ((C = GETCHAR()) == ' ' \!\! C == '\N' \!\! C == '\T') ; /* SKIP WHITE SPACE CHARACTERS */ нет ни инициализации, ни реинициализации, так что цикл WHILе выглядит самым естественным. Цикл FOR, очевидно, предпочтительнее там, где имеется простая инициализация и реинициализация, поскольку при этом управляющие циклом операторы наглядным образом оказываются вместе в начале цикла. Это наиболее очевидно в конструкции FOR (I = 0; I < N; I++) которая является идиомой языка "C" для обработки первых N элементов массива, аналогичной оператору цикла DO в фортране и PL/1. Аналогия, однако, не полная, так как границы цикла могут быть изменены внутри цикла, а управляющая переменная сохраняет свое значение после выхода из цикла, какова бы ни была причина этого выхода. Поскольку компонентами FOR могут быть произвольные выражения, они не ограничиваются только арифметическими прогрессиями. Тем не менее является плохим стилем включать в FOR вычисления, которые не относятся к уп- равлению циклом, лучше поместить их в управляемые циклом операторы. В качестве большего по размеру примера приведем другой вариант функции ATOI, преобразующей строку в ее численный эквивалент. Этот вариант является более общим; он допускает присутствие в начале символов пустых промежутков и знака + или -. (В главе 4 приведена функция ATOF, которая выполняет то же самое преобразование для чисел с плавающей точкой). Общая схема программы отражает форму поступающих данных: - пропустить пустой промежуток, если он имеется - извлечь знак, если он имеется - извлечь целую часть и преобразовать ее Каждый шаг выполняет свою часть работы и оставляет все в подготовленном состоянии для следующей части. Весь процесс заканчивается на первом символе, который не может быть частью числа. ATOI(S) /* CONVERT S TO INTEGER */ CHAR S[]; { INT I, N, SIGN; FOR(I=0;S[I]==' ' \!\! S[I]=='\N' \!\! S[I]=='\T';I++) ; /* SKIP WHITE SPACE */ SIGN = 1; IF(S[I] == '+' \!\! S[I] == '-') /* SIGN */ SIGN = (S[I++]=='+') ? 1 : - 1; FOR( N = 0; S[I] >= '0' && S[I] <= '9'; I++) N = 10 * N + S[I] - '0'; RETURN(SIGN * N); } Преимущества централизации управления циклом становятся еще более очевидными, когда имеется несколько вложенных цик- лов. Следующая функция сортирует массив целых чисел по мето- ду шелла. основная идея сортировки по шеллу заключается в том, что сначала сравниваются удаленные элементы, а не смеж- ные, как в обычном методе сортировки. Это приводит к быстро- му устранению большой части неупорядоченности и сокращает последующую работу. Интервал между элементами постепенно сокращается до единицы, когда сортировка фактически превра- щается в метод перестановки соседних элементов. SHELL(V, N) /* SORT V[0]...V[N-1] INTO INCREASING ORDER */ INT V[], N; { INT GAP, I, J, TEMP; FOR (GAP = N/2; GAP > 0; GAP /= 2) FOR (I = GAP; I < N; I++) FOR (J=I-GAP; J>=0 && V[J]>V[J+GAP]; J-=GAP) { TEMP = V[J]; V[J] = V[J+GAP]; V[J+GAP] = TEMP; } } Здесь имеются три вложенных цикла. Самый внешний цикл управ- ляет интервалом между сравниваемыми элементами, уменьшая его от N/2 вдвое при каждом проходе, пока он не станет равным нулю. Средний цикл сравнивает каждую пару элементов, разде- ленных на величину интервала; самый внутренний цикл перес- тавляет любую неупорядоченную пару. Так как интервал в конце концов сводится к единице, все элементы в результате упоря- дочиваются правильно. Отметим, что в силу общности конструк- ции FOR внешний цикл укладывается в ту же самую форму, что и остальные, хотя он и не является арифметической прогрессией. Последней операцией языка "C" является запятая ",", ко- торая чаще всего используется в операторе FOR. Два выраже- ния, разделенные запятой, вычисляются слева направо, причем типом и значением результата являются тип и значение правого операнда. Таким образом, в различные части оператора FOR можно включить несколько выражений, например, для параллель- ного изменения двух индексов. Это иллюстрируется функцией REVERSE(S), которая располагает строку S в обратном порядке на том же месте. REVERSE(S) /* REVERSE STRING S IN PLACE */ CHAR S[]; { INT C, I, J; FOR(I = 0, J = STRLEN(S) - 1; I < J; I++, J--) { C = S[I]; S[I] = S[J]; S[J] = C; } } Запятые, которые разделяют аргументы функций, переменные в описаниях и т.д., не имеют отношения к операции запятая и не обеспечивают вычислений слева направо. Упражнение 3-2 --------------- Составьте программу для функции EXPAND(S1,S2), которая расширяет сокращенные обозначения вида а-Z из строки S1 в эквивалентный полный список авс...XYZ в S2. Допускаются сок- ращения для строчных и прописных букв и цифр. Будьте готовы иметь дело со случаями типа а-в-с, а-Z0-9 и -а-Z. (Полезное соглашение состоит в том, что символ -, стоящий в начале или конце, воспринимается буквально). 3.6. Цикл DO - WHILE Как уже отмечалось в главе 1, циклы WHILE и FOR обладают тем приятным свойством, что в них проверка окончания осущес- твляется в начале, а не в конце цикла. Третий оператор цикла языка "C", DO-WHILE, проверяет условие окончания в конце, после каждого прохода через тело цикла; тело цикла всегда выполняется по крайней мере один раз. Синтаксис этого опера- тора имеет вид: DO оператор WHILE (выражение) Сначала выполняется оператор, затем вычисляется выражение. Если оно истинно, то оператор выполняется снова и т.д. Если выражение становится ложным, цикл заканчивается. Как и можно было ожидать, цикл DO-WHILE используется значительно реже, чем WHILE и FOR, составляя примерно пять процентов от всех циклов. Тем не менее, иногда он оказывает- ся полезным, как, например, в следующей функции ITOA, кото- рая преобразует число в символьную строку (обратная функции ATOI). Эта задача оказывается несколько более сложной, чем может показаться сначала. Дело в том, что простые методы вы- деления цифр генерируют их в неправильном порядке. Мы пред- почли получить строку в обратном порядке, а затем обратить ее. ITOA(N,S) /*CONVERT N TO CHARACTERS IN S */ CHAR S[]; INT N; { INT I, SIGN; IF ((SIGN = N) < 0) /* RECORD SIGN */ N = -N; /* MAKE N POSITIVE */ I = 0; DO { /* GENERATE DIGITS IN REVERSE ORDER */ S[I++] = N % 10 + '0';/* GET NEXT DIGIT */ } WHILE ((N /=10) > 0); /* DELETE IT */ IF (SIGN < 0) S[I++] = '-' S[I] = '\0'; REVERSE(S); } Цикл DO-WHILE здесь необходим, или по крайней мере удобен, поскольку, каково бы ни было значение N, массив S должен со- держать хотя бы один символ. Мы заключили в фигурные скобки один оператор, составляющий тело DO-WHILе, хотя это и не обязательно, для того, чтобы торопливый читатель не принял часть WHILE за начало оператора цикла WHILE. Упражнение 3-3 -------------- При представлении чисел в двоичном дополнительном коде наш вариант ITOA не справляется с наибольшим отрицательным числом, т.е. Со значением N рAвным -2 в степени м-1, где м - размер слова. объясните почему. Измените программу так, что- бы она правильно печатала это значение на любой машине. Упражнение 3-4 -------------- Напишите аналогичную функцию ITOB(N,S), которая преобра- зует целое без знака N в его двоичное символьное представле- ние в S. Запрограммируйте функцию ITOH, которая преобразует целое в шестнадцатеричное представление. Упражнение 3-5 --------------- Напишите вариант Iтоа, который имеет три, а не два аргу- мента. Третий аргумент - минимальная ширина поля; преобразо- ванное число должно, если это необходимо, дополняться слева пробелами, так чтобы оно имело достаточную ширину. 3.7. Оператор BREAK Иногда бывает удобным иметь возможность управлять выхо- дом из цикла иначе, чем проверкой условия в начале или в конце. Оператор BRеак позволяет выйти из операторов FOR, WHILE и DO до окончания цикла точно так же, как и из перек- лючателя. Оператор BRеак приводит к немедленному выходу из самого внутреннего охватывающего его цикла (или переключате- ля). Следующая программа удаляет хвостовые пробелы и табуля- ции из конца каждой строки файла ввода. Она использует опе- ратор BRеак для выхода из цикла, когда найден крайний правый отличный от пробела и табуляции символ. #DEFINE MAXLINE 1000 MAIN() /* REMOVE TRAILING BLANKS AND TABS */ { INT N; CHAR LINE[MAXLINE]; WHILE ((N = GETLINE(LINE,MAXLINE)) > 0) { WHILE (--N >= 0) IF (LINE[N] != ' ' && LINE[N] != '\T' && LINE[N] != '\N') BREAK; LINE[N+1] = '\0'; PRINTF("%S\N",LINE); } } Функция GETLINE возвращает длину строки. Внутренний цикл начинается с последнего символа LINE (напомним, что --N уменьшает N до использования его значения) и движется в об- ратном направлении в поиске первого символа , который отли- чен от пробела, табуляции или новой строки. Цикл прерывает- ся, когда либо найден такой символ, либо N становится отри- цательным (т.е., когда просмотрена вся строка). Советуем вам убедиться, что такое поведение правильно и в том случае, когда строка состоит только из символов пустых промежутков. В качестве альтернативы к BRеак можно ввести проверку в сам цикл: WHILE ((N = GETLINE(LINE,MAXLINE)) > 0) { WHILE (--N >= 0 && (LINE[N] == ' ' \!\! LINE[N] == '\T' \!\! LINE[N] == '\N')) ; ... } Это уступает предыдущему варианту, так как проверка стано- вится труднее для понимания. Проверок, которые требуют пе- реплетения &&, \!\!, ! И круглых скобок, по возможности сле- дует избегать. 3.8. Оператор CONTINUE Оператор CONTINUE родственен оператору BRеак, но исполь- зуется реже; он приводит к началу следующей итерации охваты- вающего цикла (FOR, WHILE, DO ). В циклах WHILE и DO это оз- начает непосредственный переход к выполнению проверочной части; в цикле FOR управление передается на шаг реинициали- зации. (Оператор CONTINUE применяется только в циклах, но не в переключателях. Оператор CONTINUE внутри переключателя внутри цикла вызывает выполнение следующей итерации цикла). В качестве примера приведем фрагмент, который обрабаты- вает только положительные элементы массива а; отрицательные значения пропускаются. FOR (I = 0; I < N; I++) { IF (A[I] < 0) /* SKIP NEGATIVE ELEMENTS */ CONTINUE; ... /* DO POSITIVE ELEMENTS */ } Оператор CONTINUE часто используется, когда последующая часть цикла оказывается слишком сложной, так что рассмотре- ние условия, обратного проверяемому, приводит к слишком глу- бокому уровню вложенности программы. Упражнение 3-6 -------------- Напишите программу копирования ввода на вывод, с тем ис- ключением, что из каждой группы последовательных одинаковых строк выводится только одна. (Это простой вариант утилиты UNIQ систем UNIX). 3.9. Оператор GOTO и метки В языке "C" предусмотрен и оператор GOTO, которым беско- нечно злоупотребляют, и метки для ветвления. С формальной точки зрения оператор GOTO никогда не является необходимым, и на практике почти всегда можно обойтись без него. Мы не использовали GOTO в этой книге. Тем не менее, мы укажем несколько ситуаций, где оператор GOTO может найти свое место. Наиболее характерным является его использование тогда, когда нужно прервать выполнение в некоторой глубоко вложенной структуре, например, выйти сразу из двух циклов. Здесь нельзя непосредственно использовать оператор BRеак, так как он прерывает только самый внутренний цикл. Поэтому: FOR ( ... ) FOR ( ... ) { ... IF (DISASTER) GOTO ERROR; } ... ERROR: CLEAN UP THE MESS Если программа обработки ошибок нетривиальна и ошибки могут возникать в нескольких местах, то такая организация оказыва- ется удобной. Метка имеет такую же форму, что и имя перемен- ной, и за ней всегда следует двоеточие. Метка может быть приписана к любому оператору той же функции, в которой нахо- дится оператор GOTO. В качестве другого примера рассмотрим задачу нахождения первого отрицательного элемента в двумерном массиве. (Много- мерные массивы рассматриваются в главе 5). Вот одна из воз- можностей: FOR (I = 0; I < N; I++) FOR (J = 0; J < M; J++) IF (V[I][J] < 0) GOTO FOUND; /* DIDN'T FIND */ ... FOUND: /* FOUND ONE AT POSITION I, J */ ... Программа, использующая оператор GOTO, всегда может быть написана без него, хотя, возможно, за счет повторения неко- торых проверок и введения дополнительных переменных. Напри- мер, программа поиска в массиве примет вид: FOUND = 0; FOR (I = 0; I < N && !FOUND; I++) FOR (J = 0; J < M && !FOUND; J++) FOUND = V[I][J] < 0; IF (FOUND) /* IT WAS AT I-1, J-1 */ ... ELSE /* NOT FOUND */ ... Хотя мы не являемся в этом вопросе догматиками, нам все же кажется, что если и нужно использовать оператор GOTO, то весьма умеренно.  * 4. Функции и структура программ *  Функции разбивают большие вычислительные задачи на ма- ленькие подзадачи и позволяют использовать в работе то, что уже сделано другими, а не начинать каждый раз с пустого мес- та. Соответствующие функции часто могут скрывать в себе де- тали проводимых в разных частях программы операций, знать которые нет необходимости, проясняя тем самым всю программу, как целое, и облегчая мучения при внесении изменений. Язык "C" разрабатывался со стремлением сделать функции эффективными и удобными для использования; "C"-программы обычно состоят из большого числа маленьких функций, а не из нескольких больших. Программа может размещаться в одном или нескольких исходных файлах любым удобным образом; исходные файлы могут компилироваться отдельно и загружаться вместе наряду со скомпилированными ранее функциями из библиотек. Мы здесь не будем вдаваться в детали этого процесса, поскольку они зависят от используемой системы. Большинство программистов хорошо знакомы с "библиотечны- ми" функциями для ввода и вывода /GETCHAR , PUTCHAR/ и для численных расчетов /SIN, COS, SQRT/. В этой главе мы сообщим больше о написании новых функций. 4.1. Основные сведения Для начала давайте разработаем и составим программу пе- чати каждой строки ввода, которая содержит определенную ком- бинацию символов. /Это - специальный случай утилиты GREP системы "UNIX"/. Например, при поиске комбинации "THE" в на- боре строк NOW IS THE TIME FOR ALL GOOD MEN TO COME TO THE AID OF THEIR PARTY в качестве выхода получим NOW IS THE TIME MEN TO COME TO THE AID OF THEIR PARTY основная схема выполнения задания четко разделяется на три части: WHILE (имеется еще строка) IF (строка содержит нужную комбинацию) вывод этой строки Конечно, возможно запрограммировать все действия в виде одной основной процедуры, но лучше использовать естественную структуру задачи и представить каждую часть в виде отдельной функции. С тремя маленькими кусками легче иметь дело, чем с одним большим, потому что отдельные не относящиеся к сущест- ву дела детали можно включить в функции и уменьшить возмож- ность нежелательных взаимодействий. Кроме того, эти куски могут оказаться полезными сами по себе. "Пока имеется еще строка" - это GETLINE, функция, кото- рую мы запрограммировали в главе 1, а "вывод этой строки" - это функция PRINTF, которую уже кто-то подготовил для нас. Это значит, что нам осталось только написать процедуру для определения, содержит ли строка данную комбинацию символов или нет. Мы можем решить эту проблему, позаимствовав разра- ботку из PL/1: функция INDEX(S,т) возвращает позицию, или индекс, строки S, где начинается строка T, и -1, если S не содержит т . В качестве начальной позиции мы используем 0, а не 1, потому что в языке "C" массивы начинаются с позиции нуль. Когда нам в дальнейшем понадобится проверять на совпа- дение более сложные конструкции, нам придется заменить толь- ко функцию INDEX; остальная часть программы останется той же самой. После того, как мы потратили столько усилий на разработ- ку, написание программы в деталях не представляет затрудне- ний. ниже приводится целиком вся программа, так что вы може- те видеть, как соединяются вместе отдельные части. Комбина- ция символов, по которой производится поиск, выступает пока в качестве символьной строки в аргументе функции INDEX, что не является самым общим механизмом. Мы скоро вернемся к об- суждению вопроса об инициализации символьных массивов и в главе 5 покажем, как сделать комбинацию символов параметром, которому присваивается значение в ходе выполнения программы. Программа также содержит новый вариант функции GETLINE; вам может оказаться полезным сравнить его с вариантом из главы 1. #DEFINE MAXLINE 1000 MAIN() /* FIND ALL LINES MATCHING A PATTERN */ { CHAR LINE[MAXLINE]; WHILE (GETLINE(LINE, MAXLINE) > 0) IF (INDEX(LINE, "THE") >= 0) PRINTF("%S", LINE); } GETLINE(S, LIM) /* GET LINE INTO S, RETURN LENGTH * CHAR S[]; INT LIM; { INT C, I; I = 0; WHILE(--LIM>0 && (C=GETCHAR()) != EOF && C != '\N') S[I++] = C; IF (C == '\N') S[I++] = C; S[I] = '\0'; RETURN(I); } INDEX(S,T) /* RETURN INDEX OF T IN S,-1 IF NONE */ CHAR S[], T[]; { INT I, J, K; FOR (I = 0; S[I] != '\0'; I++) { FOR(J=I, K=0; T[K] !='\0' && S[J] == T[K]; J++; K++) ; IF (T[K] == '\0') RETURN(I); } RETURN(-1); } Каждая функция имеет вид имя (список аргументов, если они имеются) описания аргументов, если они имеются { описания и операторы , если они имеются } Как и указывается, некоторые части могут отсутство- вать; минимальной функцией является DUMMY () { } которая не совершает никаких действий. /Такая ничего не делающая функция иногда оказывается удобной для сохранения места для дальнейшего развития прог- раммы/. если функция возвращает что-либо отличное от целого значения, то перед ее именем может стоять указатель типа; этот вопрос обсуждается в следующем разделе. Программой является просто набор определений отдельных функций. Связь между функциями осуществляется через аргумен- ты и возвращаемые функциями значения /в этом случае/; ее можно также осуществлять через внешние переменные. Функции могут располагаться в исходном файле в любом порядке, а сама исходная программа может размещаться на нескольких файлах, но так, чтобы ни одна функция не расщеплялась. Оператор RETURN служит механизмом для возвращения зна- чения из вызванной функции в функцию, которая к ней обрати- лась. За RETURN может следовать любое выражение: RETURN (выражение) Вызывающая функция может игнорировать возвращаемое значение, если она этого пожелает. Более того, после RETURN может не быть вообще никакого выражения; в этом случае в вы- зывающую программу не передается никакого значения. Управле- ние также возвращется в вызывающую программу без передачи какого-либо значения и в том случае, когда при выполнении мы "проваливаемся" на конец функции, достигая закрывающейся правой фигурной скобки. EСли функция возвращает значение из одного места и не возвращает никакого значения из другого места, это не является незаконным, но может быть признаком каких-то неприятностей. В любом случае "значением" функции, которая не возвращает значения, несомненно будет мусор. От- ладочная программа LINT проверяет такие ошибки. Механика компиляции и загрузки "C"-программ, располо- женных в нескольких исходных файлах, меняется от системы к системе. В системе "UNIX", например, эту работу выполняет команда 'CC', упомянутая в главе 1. Предположим, что три функции находятся в трех различных файлах с именами MAIN.с, GETLINE.C и INDEX.с . Тогда команда CC MAIN.C GETLINE.C INDEX.C компилирует эти три файла, помещает полученный настраиваемый объектный код в файлы MAIN.O, GETLINE.O и INDEX.O и загружа- ет их всех в выполняемый файл, называемый A.OUT . Если имеется какая-то ошибка, скажем в MAIN.C, то этот файл можно перекомпилировать отдельно и загрузить вместе с предыдущими объектными файлами по команде CC MAIN.C GETLIN.O INDEX.O Команда 'CC' использует соглашение о наименовании с ".с" и ".о" для того, чтобы отличить исходные файлы от объектных. Упражнение 4-1 ---------------- Составьте программу для функции RINDEX(S,T), которая возвращает позицию самого правого вхождения т в S и -1, если S не содержит T. 4.2. Функции, возвращающие нецелые значения До сих пор ни одна из наших программ не содержала како- го-либо описания типа функции. Дело в том, что по умолчанию функция неявно описывается своим появлением в выражении или операторе, как, например, в WHILE (GETLINE(LINE, MAXLINE) > 0) Если некоторое имя, которое не было описано ранее, появ- ляется в выражении и за ним следует левая круглая скобка, то оно по контексту считается именем некоторой функции. Кроме того, по умолчанию предполагается, что эта функция возвраща- ет значение типа INT. Так как в выражениях CHAR преобразует- ся в INT, то нет необходимости описывать функции, возвращаю- щие CHAR. Эти предположения покрывают большинство случаев, включая все приведенные до сих пор примеры. Но что происходит, если функция должна возвратить значе- ние какого-то другого типа ? Многие численные функции, такие как SQRT, SIN и COS возвращают DOUBLE; другие специальные функции возвращают значения других типов. Чтобы показать, как поступать в этом случае, давайте напишем и используем функцию ATоF(S), которая преобразует строку S в эквивалент- ное ей плавающее число двойной точности. Функция ATоF явля- ется расширением атоI, варианты которой мы написали в главах 2 и 3; она обрабатывает необязательно знак и десятичную точ- ку, а также целую и дробную часть, каждая из которых может как присутствовать, так и отсутствовать./эта процедура пре- образования ввода не очень высокого качества; иначе она бы заняла больше места, чем нам хотелось бы/. Во-первых, сама ATоF должна описывать тип возвращаемого ею значения, поскольку он отличен от INT. Так как в выраже- ниях тип FLOAT преобразуется в DOUBLE, то нет никакого смыс- ла в том, чтобы ATOF возвращала FLOAT; мы можем с равным ус- пехом воспользоваться дополнительной точностью, так что мы полагаем, что возвращаемое значение типа DOUBLE. Имя типа должно стоять перед именем функции, как показывается ниже: DOUBLE ATOF(S) /* CONVERT STRING S TO DOUBLE */ CHAR S[]; { DOUBLE VAL, POWER; INT I, SIGN; FOR(I=0; S[I]==' ' \!\! S[I]=='\N' \!\! S[I]=='\T'; I++) ; /* SKIP WHITE SPACE */ SIGN = 1; IF (S[I] == '+' \!\! S[I] == '-') /* SIGN */ SIGN = (S[I++] == '+') ? 1 : -1; FOR (VAL = 0; S[I] >= '0' && S[I] <= '9'; I++) VAL = 10 * VAL + S[I] - '0'; IF (S[I] == '.') I++; FOR (POWER = 1; S[I] >= '0' && S[I] <= '9'; I++) { VAL = 10 * VAL + S[I] - '0'; POWER *= 10; } RETURN(SIGN * VAL / POWER); } Вторым, но столь же важным, является то, что вызывающая функция должна объявить о том, что ATOF возвращает значение, отличное от INT типа. Такое объявление демонстрируется на примере следующего примитивного настольного калькулятора /едва пригодного для подведения баланса в чековой книжке/, который считывает по одному числу на строку, причем это чис- ло может иметь знак, и складывает все числа, печатая сумму после каждого ввода. #DEFINE MAXLINE 100 MAIN() /* RUDIMENTARY DESK CALKULATOR */ { DOUBLE SUM, ATOF(); CHAR LINE[MAXLINE]; SUM = 0; WHILE (GETLINE(LINE, MAXLINE) > 0) PRINTF("\T%.2F\N",SUM+=ATOF(LINE)); Оисание DOUBLE SUM, ATOF(); говорит, что SUM является переменной типа DOUBLE , и что ATOF является функцией, возвращающей значение типа DOUBLE . Эта мнемоника означает, что значениями как SUM, так и ATOF(...) являются плавающие числа двойной точности. Если функция ATOF не будет описана явно в обоих местах, то в "C" предполагается, что она возвращает целое значение, и вы получите бессмысленный ответ. Если сама ATOF и обраще- ние к ней в MAIN имеют несовместимые типы и находятся в од- ном и том же файле, то это будет обнаружено компилятором. Но если ATOF была скомпилирована отдельно /что более вероятно/, то это несоответствие не будет зафиксировано, так что ATOF будет возвращать значения типа DOUBLE, с которым MAIN будет обращаться, как с INT , что приведет к бессмысленным резуль- татам. /Программа LINT вылавливает эту ошибку/. Имея ATOF, мы, в принципе, могли бы с ее помощью напи- сать ATOI (преобразование строки в INT): ATOI(S) /* CONVERT STRING S TO INTEGER */ CHAR S[]; { DOUBLE ATOF(); RETURN(ATOF(S)); } Обратите внимание на структуру описаний и оператор RETURN. Значение выражения в RETURN (выражение) всегда преобразуется к типу функции перед выполнением самого возвращения. Поэтому при появлении в операторе RETURN значе- ние функции атоF, имеющее тип DOUBLE, автоматически преобра- зуется в INT, поскольку функция ATOI возвращает INT. (Как обсуждалось в главе 2, преобразование значения с плавающей точкой к типу INT осуществляется посредством отбрасывания дробной части). Упражнение 4-2 ---------------- Расширьте ATOF таким образом, чтобы она могла работать с числами вида 123.45е-6 где за числом с плавающей точкой может следовать 'E' и пока- затель экспоненты, возможно со знаком. 4.3. Еще об аргументах функций В главе 1 мы уже обсуждали тот факт , что аргументы фун- кций передаются по значению, т.е. вызванная функция получает свою временную копию каждого аргумента, а не его адрес. это означает, что вызванная функция не может воздействовать на исходный аргумент в вызывающей функции. Внутри функции каж- дый аргумент по существу является локальной переменной, ко- торая инициализируется тем значением, с которым к этой функ- ции обратились. Если в качестве аргумента функции выступает имя массива, то передается адрес начала этого массива; сами элементы не копируются. Функция может изменять элементы массива, исполь- зуя индексацию и адрес начала. Таким образом, массив переда- ется по ссылке. В главе 5 мы обсудим, как использование ука- зателей позволяет функциям воздействовать на отличные от массивов переменные в вызывающих функциях. Между прочим, несуществует полностью удовлетворительного способа написания переносимой функции с переменным числом аргументов. Дело в том, что нет переносимого способа, с по- мощью которого вызванная функция могла бы определить, сколь- ко аргументов было фактически передано ей в данном обраще- нии. Таким образом, вы, например, не можете написать дейст- вительно переносимую функцию, которая будет вычислять макси- мум от произвольного числа аргументов, как делают встроенные функции MAX в фортране и PL/1. Обычно со случаем переменного числа аргументов безопасно иметь дело, если вызванная функция не использует аргументов, которые ей на самом деле не были переданы, и если типы сог- ласуются. Самая распространенная в языке "C" функция с пере- менным числом - PRINTF . Она получает из первого аргумента информацию, позволяющую определить количество остальных ар- гументов и их типы. Функция PRINTF работает совершенно неп- равильно, если вызывающая функция передает ей недостаточное количество аргументов, или если их типы не согласуются с ти- пами, указанными в первом аргументе. Эта функция не является переносимой и должна модифицироваться при использовании в различных условиях. Если же типы аргументов известны, то конец списка аргу- ментов можно отметить, используя какое-то соглашение; напри- мер, считая, что некоторое специальное значение аргумента (часто нуль) является признаком конца аргументов. 4.4. Внешние переменные Программа на языке "C" состоит из набора внешних объек- тов, которые являются либо переменными, либо функциями. Тер- мин "внешний" используется главным образом в противопостав- ление термину "внутренний", которым описываются аргументы и автоматические переменные, определенные внурти функций. Внешние переменные определены вне какой-либо функции и, та- ким образом, потенциально доступны для многих функций. Сами функции всегда являются внешними, потому что правила языка "C" не разрешают определять одни функции внутри других. По умолчанию внешние переменные являются также и "глобальными", так что все ссылки на такую переменную, использующие одно и то же имя (даже из функций, скомпилированных независимо), будут ссылками на одно и то же. В этом смысле внешние пере- менные аналогичны переменным COмMON в фортране и EXTERNAL в PL/1. Позднее мы покажем, как определить внешние переменные и функции таким образом, чтобы они были доступны не глобаль- но, а только в пределах одного исходного файла. В силу своей глобальной доступности внешние переменные предоставляют другую, отличную от аргументов и возвращаемых значений, возможность для обмена данными между функциями. Если имя внешней переменной каким-либо образом описано, то любая функция имеет доступ к этой переменной, ссылаясь к ней по этому имени. В случаях, когда связь между функциями осуществляется с помощью большого числа переменных, внешние переменные оказы- ваются более удобными и эффективными, чем использование длинных списков аргументов. Как, однако, отмечалось в главе 1, это соображение следует использовать с определенной осто- рожностью, так как оно может плохо отразиться на структуре программ и приводить к программам с большим числом связей по данным между функциями. Вторая причина использования внешних переменных связана с инициализацией. В частности, внешние массивы могут быть инициализированы а автоматические нет. Мы рассмотрим вопрос об инициализации в конце этой главы. Третья причина использования внешних переменных обуслов- лена их областью действия и временем существования. Автома- тические переменные являются внутренними по отношению к фун- кциям; они возникают при входе в функцию и исчезают при вы- ходе из нее. Внешние переменные, напротив, существуют посто- янно. Они не появляютя и не исчезают, так что могут сохра- нять свои значения в период от одного обращения к функции до другого. В силу этого, если две функции используют некоторые общие данные, причем ни одна из них не обращается к другой , то часто наиболее удобным оказывается хранить эти общие дан- ные в виде внешних переменных, а не передавать их в функцию и обратно с помощью аргументов. Давайте продолжим обсуждение этого вопроса на большом примере. Задача будет состоять в написании другой программы для калькулятора, лучшей,чем предыдущая. Здесь допускаются операции +,-,*,/ и знак = (для выдачи ответа).вместо инфикс- ного представления калькулятор будет использовать обратную польскую нотацию,поскольку ее несколько легче реализовать.в обратной польской нотации знак следует за операндами; инфик- сное выражение типа (1-2)*(4+5)= записывается в виде 12-45+*= круглые скобки при этом не нужны Реализация оказывается весьма простой.каждый операнд по- мещается в стек; когда поступает знак операции,нужное число операндов (два для бинарных операций) вынимается,к ним при- меняется операция и результат направляется обратно в стек.так в приведенном выше примере 1 и 2 помещаются в стек и затем заменяются их разностью, -1.после этого 4 и 5 вво- дятся в стек и затем заменяются своей суммой,9.далее числа -1 и 9 заменяются в стеке на их произведение,равное -9.опе- рация = печатает верхний элемент стека, не удаляя его (так что промежуточные вычисления могут быть проверены). Сами операции помещения чисел в стек и их извлечения очень просты,но, в связи с включением в настоящую программу обнаружения ошибок и восстановления,они оказываются доста- точно длинными. Поэтому лучше оформить их в виде отдельных функций,чем повторять соответствующий текст повсюду в прог- рамме. Кроме того, нужна отдельная функция для выборки из ввода следующей операции или операнда. Таким образом, струк- тура программы имеет вид: WHILE( поступает операция или операнд, а не конец IF ( число ) поместить его в стек еLSE IF ( операция ) вынуть операнды из стека выполнить операцию поместить результат в стек ELSE ошибка Основной вопрос, который еще не был обсужден, заключает- ся в том,где поместить стек, т. Е. Какие процедуры смогут обращаться к нему непосредственно. Одна из таких возможнос- тей состоит в помещении стека в MAIN и передачи самого стека и текущей позиции в стеке функциям, работающим со стеком. Но функции MAIN нет необходимости иметь дело с переменными, уп- равляющими стеком; ей естественно рассуждать в терминах по- мещения чисел в стек и извлечения их оттуда. В силу этого мы решили сделать стек и связанную с ним информацию внешними переменными , доступными функциям PUSH (помещение в стек) и POP (извлечение из стека), но не MAIN. Перевод этой схемы в программу достаточно прост. Ведущая программа является по существу большим переключателем по ти- пу операции или операнду; это, по-видимому, более характер- ное применеие переключателя, чем то, которое было продемонс- трировано в главе 3. #DEFINE MAXOP 20 /* MAX SIZE OF OPERAND, OPERАTOR * #DEFINE NUMBER '0' /* SIGNAL THAT NUMBER FOUND */ #DEFINE TOOBIG '9' /* SIGNAL THAT STRING IS TOO BIG * MAIN() /* REVERSE POLISH DESK CALCULATOR */ /( INT TUPE; CHAR S[MAXOP]; DOUBLE OP2,ATOF(),POP(),PUSH(); WHILE ((TUPE=GETOP(S,MAXOP)) !=EOF); SWITCH(TUPE) /( CASE NUMBER: PUSH(ATOF(S)); BREAK; CASE '+': PUSH(POP()+POP()); BREAK; CASE '*': PUSH(POP()*POP()); BREAK; CASE '-': OP2=POP(); PUSH(POP()-OP2); BREAK; CASE '/': OP2=POP(); IF (OP2 != 0.0) PUSH(POP()/OP2); ELSE PRINTF("ZERO DIVISOR POPPED\N"); BREAK; CASE '=': PRINTF("\T%F\N",PUSH(POP())); BREAK; CASE 'C': CLEAR(); BREAK; CASE TOOBIG: PRINTF("%.20S ... IS TOO LONG\N",S) BREAK; /) /) #DEFINE MAXVAL 100 /* MAXIMUM DEPTH OF VAL STACK */ INT SP = 0; /* STACK POINTER */ DOUBLE VAL[MAXVAL]; /*VALUE STACK */ DOUBLE PUSH(F) /* PUSH F ONTO VALUE STACK */ DOUBLE F; /( IF (SP < MAXVAL) RETURN(VAL[SP++] =F); ELSE /( PRINTF("ERROR: STACK FULL\N"); CLEAR(); RETURN(0); /) /) DOUBLE POP() /* POP TOP VALUE FROM STEACK */ /( IF (SP > 0) RETURN(VAL[--SP]); ELSE /( PRINTF("ERROR: STACK EMPTY\N"); CLEAR(); RETURN(0); /) /) CLEAR() /* CLEAR STACK */ /( SP=0; /) Команда C очищает стек с помощью функции CLEAR, которая также используется в случае ошибки функциями PUSH и POP. к функции GETOP мы очень скоро вернемся. Как уже говорилось в главе 1, переменная является внеш- ней, если она определена вне тела какой бы то ни было функ- ции. Поэтому стек и указатель стека, которые должны исполь- зоваться функциями PUSH, POP и CLEAR, определены вне этих трех функций. Но сама функция MAIN не ссылается ни к стеку, ни к указателю стека - их участие тщательно замаскировано. В силу этого часть программы, соответствующая операции = , ис- пользует конструкцию PUSH(POP()); для того, чтобы проанализировать верхний элемент стека, не изменяя его. Отметим также, что так как операции + и * коммутативны, порядок, в котором объединяются извлеченные операнды, несу- щественен, но в случае операций - и / необходимо различать левый и правый операнды. Упражнение 4-3 --------------- Приведенная основная схема допускает непосредственное расширение возможностей калькулятора. Включите операцию де- ления по модулю /%/ и унарный минус. Включите команду "сте- реть", которая удаляет верхний элемент стека. Введите коман- ды для работы с переменными. /Это просто, если имена пере- менных будут состоять из одной буквы из имеющихся двадцати шести букв/. 4.5. Правила, определяющие область действия Функции и внешние переменные, входящие в состав "C"-программы, не обязаны компилироваться одновременно; программа на исходном языке может располагаться в нескольких файлах, и ранее скомпилированные процедуры могут загружаться из библиотек. Два вопроса представляют интерес: Как следует составлять описания, чтобы переменные пра- вильно воспринимались во время компиляции ? Как следует составлять описания, чтобы обеспечить пра- вильную связь частей программы при загрузке ? 4.5.1. Область действия Областью действия имени является та часть программы, в которой это имя определено. Для автоматической переменной, описанной в начале функции, областью действия является та функция, в которой описано имя этой переменной, а переменные из разных функций, имеющие одинаковое имя, считаются не от- носящимися друг к другу. Это же справедливо и для аргументов функций. Область действия внешней переменной простирается от точ- ки, в которой она объявлена в исходном файле, до конца этого файла. Например, если VAL, SP, PUSH, POP и CLEAR определены в одном файле в порядке, указанном выше, а именно: INT SP = 0; DOUBLE VAL[MAXVAL]; DOUBLE PUSH(F) {...} DOUBLE POP() {...} CLEAR() {...} то переменные VAL и SP можно использовать в PUSH, POP и CLEAR прямо по имени; никакие дополнительные описания не нужны. С другой стороны, если нужно сослаться на внешнюю пере- менную до ее определения, или если такая переменная опреде- лена в файле, отличном от того, в котором она используется, то необходимо описание EXTERN. Важно различать описание внешней переменной и ее опреде- ление. описание указывает свойства переменной /ее тип, раз- мер и т.д./; определение же вызывает еще и отведение памяти. Если вне какой бы то ни было функции появляются строчки INT SP; DOUBLE VAL[MAXVAL]; то они определяют внешние переменные SP и VAL, вызывают от- ведение памяти для них и служат в качестве описания для ос- тальной части этого исходного файла. В то же время строчки EXTERN INT SP; EXTERN DOUBLE VAL[]; описывают в остальной части этого исходного файла переменную SP как INT, а VAL как массив типа DOUBLE /размер которого указан в другом месте/, но не создают переменных и не отво- дят им места в памяти. Во всех файлах, составляющих исходную программу, должно содержаться только одно определение внешней переменной; дру- гие файлы могут содержать описания EXTERN для доступа к ней. /Описание EXTERN может иметься и в том файле, где находится определение/. Любая инициализация внешней переменной прово- дится только в определении. В определении должны указываться размеры массивов, а в описании EXTERN этого можно не делать. Хотя подобная организация приведенной выше программы и маловероятна, но VAL и SP могли бы быть определены и инициа- лизированы в одном файле, а функция PUSH, POP и CLEAR опре- делены в другом. В этом случае для связи были бы необходимы следующие определения и описания: в файле 1: ---------- INT SP = 0; /* STACK POINTER */ DOUBLE VAL[MAXVAL]; /* VALUE STACK */ в файле 2: ---------- EXTERN INT SP; EXTERN DOUBLE VAL[]; DOUBLE PUSH(F) {...} DOUBLE POP() {...} CLEAR() {...} так как описания EXTERN 'в файле 1' находятся выше и вне трех указанных функций, они относятся ко всем ним; одного набора описаний достаточно для всего 'файла 2'. Для программ большого размера обсуждаемая позже в этой главе возможность включения файлов, #INCLUDE, позволяет иметь во всей программе только одну копию описаний EXTERN и вставлять ее в каждый исходный файл во время его компиляции. Обратимся теперь к функции GETOP, выбирающей из файла ввода следующую операцию или операнд. Основная задача прос- та: пропустить пробелы, знаки табуляции и новые строки. Если следующий символ отличен от цифры и десятичной точки, то возвратить его. В противном случае собрать строку цифр /она может включать десятичную точку/ и возвратить NUMBER как сигнал о том, что выбрано число. Процедура существенно усложняется, если стремиться пра- вильно обрабатывать ситуацию, когда вводимое число оказыва- ется слишком длинным. Функция GETOP считывает цифры подряд /возможно с десятичной точкой/ и запоминает их, пока после- довательность не прерывается. Если при этом не происходит переполнения, то функция возвращает NUMBER и строку цифр. Если же число оказывается слишком длинным, то GETOP отбрасы- вает остальную часть строки из файла ввода, так что пользо- ватель может просто перепечатать эту строку с места ошибки; функция возвращает TOOBIG как сигнал о переполнении. GETOP(S, LIM) /* GET NEXT OPRERATOR OR OPERAND */ CHAR S[]; INT LIM; { INT I, C; WHILE((C=GETCH())==' '\!\! C=='\T' \!\! C=='\N') ; IF (C != '.' && (C < '0' \!\! C > '9')) RETURN(C); S[0] = C; FOR(I=1; (C=GETCHAR()) >='0' && C <= '9'; I++) IF (I < LIM) S[I] = C; IF (C == '.') { /* COLLECT FRACTION */ IF (I < LIM) S[I] = C; FOR(I++;(C=GETCHAR()) >='0' && C<='9';I++) IF (I < LIM) S[I] =C; } IF (I < LIM) { /* NUMBER IS OK */ UNGETCH(C); S[I] = '\0'; RETURN (NUMBER); } ELSE { /* IT'S TOO BIG; SKIP REST OF LINE */ WHILE (C != '\N' && C != EOF) C = GETCHAR(); S[LIM-1] = '\0'; RETURN (TOOBIG); } } Что же представляют из себя функции 'GETCH' и 'UNGETCH'? Часто так бывает, что программа, считывающая входные данные, не может определить, что она прочла уже достаточно, пока она не прочтет слишком много. Одним из примеров является выбор символов, составляющих число: пока не появится символ, от- личный от цифры, число не закончено. Но при этом программа считывает один лишний символ, символ, для которого она еще не подготовлена. Эта проблема была бы решена, если бы было бы возможно "прочесть обратно" нежелательный символ. Тогда каждый раз, прочитав лишний символ, программа могла бы поместить его об- ратно в файл ввода таким образом, что остальная часть прог- раммы могла бы вести себя так, словно этот символ никогда не считывался. к счастью, такое неполучение символа легко имми- тировать, написав пару действующих совместно функций. Функ- ция GETCH доставляет следующий символ ввода, подлежащий рас- смотрению; функция UNGETCH помещает символ назад во ввод, так что при следующем обращении к GETCH он будет возвращен. То, как эти функции совместно работают, весьма просто. Функция UNGETCH помещает возвращаемые назад символы в сов- местно используемый буфер, являющийся символьным массивом. Функция GETCH читает из этого буфера, если в нем что-либо имеется; если же буфер пуст, она обращается к GETCHAR. При этом также нужна индексирующая переменная, которая будет фиксировать позицию текущего символа в буфере. Так как буфер и его индекс совместно используются функ- циями GETCH и UNGETCH и должны сохранять свои значения в пе- риод между обращениями, они должны быть внешними для обеих функций. Таким образом, мы можем написать GETCH, UNGETCH и эти переменные как: #DEFINE BUFSIZE 100 CHAR BUF[BUFSIZE]; /* BUFFER FOR UNGETCH */ INT BUFP = 0; /* NEXT FREE POSITION IN BUF */ GETCH() /* GET A (POSSIBLY PUSHED BACK) CHARACTER */ { RETURN((BUFP > 0) ? BUF[--BUFP] : GETCHAR()); } UNGETCH(C) /* PUSH CHARACTER BACK ON INPUT */ INT C; { IF (BUFP > BUFSIZE) PRINTF("UNGETCH: TOO MANY CHARACTERS\N"); ELSE BUF [BUFP++] = C; } Мы использовали для хранения возвращаемых символов массив, а не отдельный символ, потому что такая общность может приго- диться в дальнейшем. Упражнение 4-4 ---------------- Напишите функцию UNGETS(S) , которая будет возвращать во ввод целую строку. Должна ли UNGETS иметь дело с BUF и BUFP или она может просто использовать UNGETCH ? Упражнение 4-5 ---------------- Предположите, что может возвращаться только один символ. Из- мените GETCH и UNGETCH соответствующим образом. Упражнение 4-6 ---------------- Наши функции GETCH и UNGETCH не обеспечивают обработку возв- ращенного символа EOF переносимым образом. Решите, каким свойством должны обладать эти функции, если возвращается EOF, и реализуйте ваши выводы. 4.6. Статические переменные Статические переменные представляют собой третий класс памяти, в дополнении к автоматическим переменным и EXTERN, с которыми мы уже встречались. Статические переменные могут быть либо внутренними, либо внешними. Внутренние статические переменные точно так же, как и автоматические, являются локальными для некоторой фун- кции, но, в отличие от автоматических, они остаются сущест- вовать, а не появляются и исчезают вместе с обращением к этой функции. это означает, что внутренние статические пере- менные обеспечивают постоянное, недоступное извне хранение внутри функции. Символьные строки, появляющиеся внутри функ- ции, как, например, аргументы PRINTF , являются внутренними статическими. Внешние статические переменные определены в остальной части того исходного файла, в котором они описаны, но не в каком-либо другом файле. Таким образом, они дают способ скрывать имена, подобные BUF и BUFP в комбинации GETCH-UNGETCH, которые в силу их совместного использования должны быть внешними, но все же не доступными для пользова- телей GETCH и UNGETCH , чтобы исключалась возможность конф- ликта. Если эти две функции и две переменные объеденить в одном файле следующим образом STATIC CHAR BUF[BUFSIZE]; /* BUFFER FOR UNGETCH */ STATIC INT BUFP=0; /*NEXT FREE POSITION IN BUF */ GETCH() {...} UNGETCH() {...} то никакая другая функция не будет в состоянии обратиться к BUF и BUFP; фактически, они не будут вступать в конфликт с такими же именами из других файлов той же самой программы. Статическая память, как внутренняя, так и внешняя, спе- цифицируется словом STATIC , стоящим перед обычным описани- ем. Переменная является внешней, если она описана вне какой бы то ни было функции, и внутренней, если она описана внутри некоторой функции. Нормально функции являются внешними объектами; их имена известны глобально. возможно, однако, объявить функцию как STATIC ; тогда ее имя становится неизвестным вне файла, в котором оно описано. В языке "C" "STATIC" отражает не только постоянство, но и степень того, что можно назвать "приватностью". Внутренние статические объекты определены только внутри одной функции; внешние статические объекты /переменные или функции/ опреде- лены только внутри того исходного файла, где они появляются, и их имена не вступают в конфликт с такими же именами пере- менных и функций из других файлов. Внешние статические переменные и функции предоставляют способ организовывать данные и работающие с ними внутренние процедуры таким образом, что другие процедуры и данные не могут прийти с ними в конфликт даже по недоразумению. Напри- мер, функции GETCH и UNGETCH образуют "модуль" для ввода и возвращения символов; BUF и BUFP должны быть статическими, чтобы они не были доступны извне. Точно так же функции PUSH, POP и CLEAR формируют модуль обработки стека; VAR и SP тоже должны быть внешними статическими. 4.7. Регистровые переменные Четвертый и последний класс памяти называется регистро- вым. Описание REGISTER указывает компилятору, что данная пе- ременная будет часто использоваться. Когда это возможно, пе- ременные, описанные как REGISTER, располагаются в машинных регистрах, что может привести к меньшим по размеру и более быстрым программам. Описание REGISTER выглядит как REGISTER INT X; REGISTER CHAR C; и т.д.; часть INT может быть опущена. Описание REGISTER мож- но использовать только для автоматических переменных и фор- мальных параметров функций. В этом последнем случае описания выглядят следующим образом: F(C,N) REGISTER INT C,N; { REGISTER INT I; ... } На практике возникают некоторые ограничения на регистро- вые переменные, отражающие реальные возможности имеющихся аппаратных средств. В регистры можно поместить только нес- колько переменных в каждой функции, причем только определен- ных типов. В случае превышения возможного числа или исполь- зования неразрешенных типов слово REGISTER игнорируется. Кроме того невозможно извлечь адрес регистровой переменной (этот вопрос обсуждается в главе 5). Эти специфические огра- ничения варьируются от машины к машине. Так, например, на PDP-11 эффективными являются только первые три описания REGISTER в функции, а в качестве типов допускаются INT, CHAR или указатель. 4.8. Блочная структура Язык "C" не является языком с блочной структурой в смыс- ле PL/1 или алгола; в нем нельзя описывать одни функции внутри других. Переменные же, с другой стороны, могут определяться по методу блочного структурирования. Описания переменных (вклю- чая инициализацию) могут следовать за левой фигурной скоб- кой,открывающей любой оператор, а не только за той, с кото- рой начинается тело функции. Переменные, описанные таким об- разом, вытесняют любые переменные из внешних блоков, имеющие такие же имена, и остаются определенными до соответствующей правой фигурной скобки. Например в IF (N > 0) { INT I; /* DECLARE A NEW I */ FOR (I = 0; I < N; I++) ... } Областью действия переменной I является "истинная" ветвь IF; это I никак не связано ни с какими другими I в програм- ме. Блочная структура влияет и на область действия внешних переменных. Если даны описания INT X; F() { DOUBLE X; ... } То появление X внутри функции F относится к внутренней пере- менной типа DOUBLE, а вне F - к внешней целой переменной. это же справедливо в отношении имен формальных параметров: INT X; F(X) DOUBLE X; { ... } Внутри функции F имя X относится к формальному параметру, а не к внешней переменной. 4.9. Инициализация Мы до сих пор уже много раз упоминали инициализацию, но всегда мимоходом , среди других вопросов. Теперь, после того как мы обсудили различные классы памяти, мы в этом разделе просуммируем некоторые правила, относящиеся к инициализации. Если явная инициализация отсутствует, то внешним и ста- тическим переменным присваивается значение нуль; автомати- ческие и регистровые переменные имеют в этом случае неопре- деленные значения (мусор). Простые переменные (не массивы или структуры) можно ини- циализировать при их описании, добавляя вслед за именем знак равенства и константное выражение: INT X = 1; CHAR SQUOTE = '\''; LONG DAY = 60 * 24; /* MINUTES IN A DAY */ Для внешних и статических переменных инициализация выполня- ется только один раз, на этапе компиляции. Автоматические и регистровые переменные инициализируются каждый раз при входе в функцию или блок. В случае автоматических и регистровых переменных инициализа- тор не обязан быть константой: на самом деле он может быть любым значимым выражением, которое может включать определен- ные ранее величины и даже обращения к функциям. Например, инициализация в программе бинарного поиска из главы 3 могла бы быть записана в виде BINARY(X, V, N) INT X, V[], N; { INT LOW = 0; INT HIGH = N - 1; INT MID; ... } вместо BINARY(X, V, N) INT X, V[], N; { INT LOW, HIGH, MID; LOW = 0; HIGH = N - 1; ... } По своему результату, инициализации автоматических перемен- ных являются сокращенной записью операторов присваивания. Какую форму предпочесть - в основном дело вкуса. мы обычно используем явные присваивания, потому что инициализация в описаниях менее заметна. Автоматические массивы не могут быть инициализированы. Внеш- ние и статические массивы можно инициализировать, помещая вслед за описанием заключенный в фигурные скобки список на- чальных значений, разделенных запятыми. Например программа подсчета символов из главы 1, которая начиналась с 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; ... ) Ожет быть переписана в виде INT NWHITE = 0; INT NOTHER = 0; INT NDIGIT[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; MAIN() /* COUNT DIGITS, WHITE SPACE, OTHERS */ ( INT C, I; ... ) Эти инициализации фактически не нужны, так как все присваи- ваемые значения равны нулю, но хороший стиль - сделать их явными. Если количество начальных значений меньше, чем ука- занный размер массива, то остальные элементы заполняются ну- лями. Перечисление слишком большого числа начальных значений является ошибкой. К сожалению, не предусмотрена возможность указания, что некоторое начальное значение повторяется, и нельзя инициализировать элемент в середине массива без пере- числения всех предыдущих. Для символьных массивов существует специальный способ инициализации; вместо фигурных скобок и запятых можно ис- пользовать строку: CHAR PATTERN[] = "THE"; Это сокращение более длинной, но эквивалентной записи: CHAR PATTERN[] = { 'T', 'H', 'E', '\0' }; Если размер массива любого типа опущен, то компилятор опре- деляет его длину, подсчитывая число начальных значений. В этом конкретном случае размер равен четырем (три символа плюс конечное \0). 4.10. Рекурсия В языке "C" функции могут использоваться рекурсивно; это означает, что функция может прямо или косвенно обращаться к себе самой. Традиционным примером является печать числа в виде строки символов. как мы уже ранее отмечали, цифры гене- рируются не в том порядке: цифры младших разрядов появляются раньше цифр из старших разрядов, но печататься они должны в обратном порядке. Эту проблему можно решить двумя способами. Первый спо- соб, которым мы воспользовались в главе 3 в функции ITOA, заключается в запоминании цифр в некотором массиве по мере их поступления и последующем их печатании в обратном поряд- ке. Первый вариант функции PRINTD следует этой схеме. PRINTD(N) /* PRINT N IN DECIMAL */ INT N; { CHAR S[10]; INT I; IF (N < 0) { PUTCHAR('-'); N = -N; } I = 0; DO { S[I++] = N % 10 + '0'; /* GET NEXT CHAR */ } WHILE ((N /= 10) > 0); /* DISCARD IT */ WHILE (--I >= 0) PUTCHAR(S[I]); } Альтернативой этому способу является рекурсивное реше- ние, когда при каждом вызове функция PRINTD сначала снова обращается к себе, чтобы скопировать лидирующие цифры, а за- тем печатает последнюю цифру. PRINTD(N) /* PRINT N IN DECIMAL (RECURSIVE)*/ INT N; ( INT I; IF (N < 0) { PUTCHAR('-'); N = -N; } IF ((I = N/10) != 0) PRINTD(I); PUTCHAR(N % 10 + '0'); ) Когда функция вызывает себя рекурсивно, при каждом обра- щении образуется новый набор всех автоматических переменных, совершенно не зависящий от предыдущего набора. Таким обра- зом, в PRINTD(123) первая функция PRINTD имеет N = 123. Она передает 12 второй PRINTD, а когда та возвращает управление ей, печатает 3. Точно так же вторая PRINTD передает 1 третьей (которая эту единицу печатает), а затем печатает 2. Рекурсия обычно не дает никакой экономиии памяти, пос- кольку приходится где-то создавать стек для обрабатываемых значений. Не приводит она и к созданию более быстрых прог- рамм. Но рекурсивные программы более компактны, и они зачас- тую становятся более легкими для понимания и написания. Ре- курсия особенно удобна при работе с рекурсивно определяемыми структурами данных, например, с деревьями; хороший пример будет приведен в главе 6. Упражнение 4-7 -------------- Приспособьте идеи, использованные в PRINTD для рекурсив- ного написания ITOA; т.е. Преобразуйте целое в строку с по- мощью рекурсивной процедуры. Упражнение 4-8 -------------- Напишите рекурсивный вариант функции REVERSE(S), которая располагает в обратном порядке строку S. 4.11. Препроцессор языка "C" В языке "с" предусмотрены определенные расширения языка с помощью простого макропредпроцессора. одним из самых расп- ространенных таких расширений, которое мы уже использовали, является конструкция #DEFINE; другим расширением является возможность включать во время компиляции содержимое других файлов. 4.11.1. Включение файлов Для облегчения работы с наборами конструкций #DEFINE и описаний (среди прочих средств) в языке "с" предусмотрена возможность включения файлов. Любая строка вида #INCLUDE "FILENAME" заменяется содержимым файла с именем FILENAME. (Кавычки обя- зательны). Часто одна или две строки такого вида появляются в начале каждого исходного файла, для того чтобы включить общие конструкции #DEFINE и описания EXTERN для глобальных переменных. Допускается вложенность конструкций #INCLUDE. Конструкция #INCLUDE является предпочтительным способом связи описаний в больших программах. Этот способ гарантиру- ет, что все исходные файлы будут снабжены одинаковыми опре- делениями и описаниями переменных, и, следовательно, исклю- чает особенно неприятный сорт ошибок. Естественно, когда ка- кой-TO включаемый файл изменяется, все зависящие от него файлы должны быть перекомпилированы. 4.11.2. Макроподстановка Определение вида #DEFINE TES 1 приводит к макроподстановке самого простого вида - замене имени на строку символов. Имена в #DEFINE имеют ту же самую форму, что и идентификаторы в "с"; заменяющий текст совер- шенно произволен. Нормально заменяющим текстом является ос- тальная часть строки; длинное определение можно продолжить, поместив \ в конец продолжаемой строки. "Область действия" имени, определенного в #DEFINE, простирается от точки опре- деления до конца исходного файла. имена могут быть переопре- делены, и определения могут использовать определения, сде- ланные ранее. Внутри заключенных в кавычки строк подстановки не производятся, так что если, например, YES - определенное имя, то в PRINTF("YES") не будет сделано никакой подстанов- ки. Так как реализация #DEFINE является частью работы маKропредпроцессора, а не собственно компилятора, имеется очень мало грамматических ограничений на то, что может быть определено. Так, например, любители алгола могут объявить #DEFINE THEN #DEFINE BEGIN { #DEFINE END ;} и затем написать IF (I > 0) THEN BEGIN A = 1; B = 2 END Имеется также возможность определения макроса с аргумен- тами, так что заменяющий текст будет зависеть от вида обра- щения к макросу. Определим, например, макрос с именем MAX следующим образом: #DEFINE MAX(A, B) ((A) > (B) ? (A) : (B)) когда строка X = MAX(P+Q, R+S); будет заменена строкой X = ((P+Q) > (R+S) ? (P+Q) : (R+S)); Такая возможность обеспечивает "функцию максимума", которая расширяется в последовательный код, а не в обращение к функ- ции. При правильном обращении с аргументами такой макрос бу- дет работать с любыми типами данных; здесь нет необходимости в различных видах MAX для данных разных типов, как это было бы с функциями. Конечно, если вы тщательно рассмотрите приведенное выше расширение MAX, вы заметите определенные недостатки. Выраже- ния вычисляются дважды; это плохо, если они влекут за собой побочные эффекты, вызванные, например, обращениями к функци- ям или использованием операций увеличения. Нужно позаботить- ся о правильном использовании круглых скобок, чтобы гаранти- ровать сохранение требуемого порядка вычислений. (Рассмотри- те макрос #DEFINE SQUARE(X) X * X при обращении к ней, как SQUARE(Z+1)). Здесь возникают даже некоторые чисто лексические проблемы: между именем макро и левой круглой скобкой, открывающей список ее аргументов, не должно быть никаких пробелов. Тем не менее аппарат макросов является весьма ценным. Один практический пример дает описываемая в главе 7 стандар- тная библиотека ввода-вывода, в которой GETCHAR и PUTCHAR определены как макросы (очевидно PUTCHAR должна иметь аргу- мент), что позволяет избежать затрат на обращение к функции при обработке каждого символа. Другие возможности макропроцессора описаны в приложении А. Упражнение 4-9 --------------- Определите макрос SWAP(X, Y), который обменивает значе- ниями два своих аргумента типа INT. (В этом случае поможет блочная структура).  * 5. Указатели и массивы *  Указатель - это переменная, содержащая адрес другой пе- ременной. указатели очень широко используются в языке "C". Это происходит отчасти потому, что иногда они дают единст- венную возможность выразить нужное действие, а отчасти пото- му, что они обычно ведут к более компактным и эффективным программам, чем те, которые могут быть получены другими спо- собами. Указатели обычно смешивают в одну кучу с операторами GOTO, характеризуя их как чудесный способ написания прог- рамм, которые невозможно понять. Это безусловно спрAведливо, если указатели используются беззаботно; очень просто ввести указатели, которые указывают на что-то совершенно неожидан- ное. Однако, при определенной дисциплине, использование ука- зателей помогает достичь ясности и простоты. Именно этот ас- пект мы попытаемся здесь проиллюстрировать. 5.1. Указатели и адреса Так как указатель содержит адрес объекта, это дает воз- можность "косвенного" доступа к этому объекту через указа- тель. Предположим, что х - переменная, например, типа INT, а рх - указатель, созданный неким еще не указанным способом. Унарная операция & выдает адрес объекта, так что оператор рх = &х; присваивает адрес х переменной рх; говорят, что рх "ука- зывает" на х. Операция & применима только к переменным и элементам массива, конструкции вида &(х-1) и &3 являются не- законными. Нельзя также получить адрес регистровой перемен- ной. Унарная операция * рассматривает свой операнд как адрес конечной цели и обращается по этому адресу, чтобы извлечь содержимое. Следовательно, если Y тоже имеет тип INT, то Y = *рх; присваивает Y содержимое того, на что указывает рх. Так пос- ледовательность рх = &х; Y = *рх; присваивает Y то же самое значение, что и оператор Y = X; Переменные, участвующие во всем этом необходимо описать: INT X, Y; INT *PX; с описанием для X и Y мы уже неодонократно встречались. Описание указателя INT *PX; является новым и должно рассматриваться как мнемоническое; оно говорит, что комбинация *PX имеет тип INT. Это означает, что если PX появляется в контексте *PX, то это эквивалентно переменной типа INT. Фактически синтаксис описания перемен- ной имитирует синтаксис выражений, в которых эта переменная может появляться. Это замечание полезно во всех случаях, связанных со сложными описаниями. Например, DOUBLE ATOF(), *DP; говорит, что ATOF() и *DP имеют в выражениях значения типа DOUBLE. Вы должны также заметить, что из этого описания следу- ет, что указатель может указывать только на определенный вид объектов. Указатели могут входить в выражения. Например, если PX указывает на целое X, то *PX может появляться в любом кон- тексте, где может встретиться X. Так оператор Y = *PX + 1 присваивает Y значение, на 1 большее значения X; PRINTF("%D\N", *PX) печатает текущее значение X; D = SQRT((DOUBLE) *PX) получает в D квадратный корень из X, причем до передачи фун- кции SQRT значение X преобразуется к типу DOUBLE. (Смотри главу 2). В выражениях вида Y = *PX + 1 унарные операции * и & связаны со своим операндом более крепко, чем арифметические операции, так что такое выражение берет то значение, на которое указывает PX, прибавляет 1 и присваивает результат переменной Y. Мы вскоре вернемся к то- му, что может означать выражение Y = *(PX + 1) Ссылки на указатели могут появляться и в левой части присваиваний. Если PX указывает на X, то *PX = 0 полагает X равным нулю, а *PX += 1 увеличивает его на единицу, как и выражение (*PX)++ Круглые скобки в последнем примере необходимы; если их опус- тить, то поскольку унарные операции, подобные * и ++, выпол- няются справа налево, это выражение увеличит PX, а не ту пе- ременную, на которую он указывает. И наконец, так как указатели являются переменными, то с ними можно обращаться, как и с остальными переменными. Если PY - другой указатель на переменную типа INT, то PY = PX копирует содержимое PX в PY, в результате чего PY указывает на то же, что и PX. 5.2. Указатели и аргументы функций Так как в "с" передача аргументов функциям осуществляет- ся "по значению", вызванная процедура не имеет непосредст- венной возможности изменить переменную из вызывающей прог- раммы. Что же делать, если вам действительно надо изменить аргумент? например, программа сортировки захотела бы поме- нять два нарушающих порядок элемента с помощью функции с именем SWAP. Для этого недостаточно написать SWAP(A, B); определив функцию SWAP при этом следующим образом: SWAP(X, Y) /* WRONG */ INT X, Y; { INT TEMP; TEMP = X; X = Y; Y = TEMP; } из-за вызова по значению SWAP не может воздействовать на агументы A и B в вызывающей функции. К счастью, все же имеется возможность получить желаемый эффект. Вызывающая программа передает указатели подлежащих изменению значений: SWAP(&A, &B); так как операция & выдает адрес переменной, то &A является указателем на A. В самой SWAP аргументы описываются как ука- затели и доступ к фактическим операндам осуществляется через них. SWAP(PX, PY) /* INTERCHANGE *PX AND *PY */ INT *PX, *PY; { INT TEMP; TEMP = *PX; *PX = *PY; *PY = TEMP; } Указатели в качестве аргументов обычно используются в функциях, которые должны возвращать более одного значения. (Можно сказать, что SWAP вOзвращает два значения, новые зна- чения ее аргументов). В качестве примера рассмотрим функцию GETINT, которая осуществляет преобразование поступающих в своболном формате данных, разделяя поток символов на целые значения, по одному целому за одно обращение. Функция GETINT должна возвращать либо найденное значение, либо признак кон- ца файла, если входные данные полностью исчерпаны. Эти зна- чения должны возвращаться как отдельные объекты, какое бы значение ни использовалось для EOF, даже если это значение вводимого целого. Одно из решений, основывающееся на описываемой в главе 7 функции ввода SCANF, состоит в том, чтобы при выходе на ко- нец файла GETINT возвращала EOF в качестве значения функции; любое другое возвращенное значение говорит о нахождении нор- мального целого. Численное же значение найденного целого возвращается через аргумент, который должен быть указателем целого. Эта организация разделяет статус конца файла и чис- ленные значения. Следующий цикл заполняет массив целыми с помощью обраще- ний к функции GETINT: INT N, V, ARRAY[SIZE]; FOR (N = 0; N < SIZE && GETINT(&V) != EOF; N++) ARRAY[N] = V; В результате каждого обращения V становится равным следующе- му целому значению, найденному во входных данных. Обратите внимание, что в качестве аргумента GETINT необходимо указать &V а не V. Использование просто V скорее всего приведет к ошибке адресации, поскольку GETINT полагает, что она работа- ет именно с указателем. Сама GETINT является очевидной модификацией написанной нами ранее функции ATOI: GETINT(PN) /* GET NEXT INTEGER FROM INPUT */ INT *PN; { INT C,SIGN; WHILE ((C = GETCH()) == ' ' \!\! C == '\N' \!\! C == '\T'); /* SKIP WHITE SPACE */ SIGN = 1; IF (C == '+' \!\! C == '-') { /* RECORD SIGN */ SIGN = (C == '+') ? 1 : -1; C = GETCH(); } FOR (*PN = 0; C >= '0' && C <= '9'; C = GETCH()) *PN = 10 * *PN + C - '0'; *PN *= SIGN; IF (C != EOF) UNGETCH(C); RETURN(C); } Выражение *PN используется всюду в GETINT как обычная пере- менная типа INT. Мы также использовали функции GETCH и UNGETCH (описанные в главе 4) , так что один лишний символ, кототрый приходится считывать, может быть помещен обратно во ввод. Упражнение 5-1 --------------- Напишите функцию GETFLOAT, аналог GETINT для чисел с плавающей точкой. Какой тип должна возвращать GETFLOAT в ка- честве значения функции? 5.3. Указатели и массивы В языке "C" существует сильная взаимосвязь между указа- телями и массивами , настолько сильная, что указатели и мас- сивы действительно следует рассматривать одновременно. Любую операцию, которую можно выполнить с помощью индексов масси- ва, можно сделать и с помощью указателей. вариант с указате- лями обычно оказывается более быстрым, но и несколько более трудным для непосредственного понимания, по крайней мере для начинающего. описание INT A[10] определяет массив размера 10, т.е. Набор из 10 последова- тельных объектов, называемых A[0], A[1], ..., A[9]. Запись A[I] соответствует элементу массива через I позиций от нача- ла. Если PA - указатель целого, описанный как INT *PA то присваивание PA = &A[0] приводит к тому, что PA указывает на нулевой элемент массива A; это означает, что PA содержит адрес элемента A[0]. Теперь присваивание X = *PA будет копировать содержимое A[0] в X. Если PA указывает на некоторый определенный элемент мас- сива A, то по определению PA+1 указывает на следующий эле- мент, и вообще PA-I указывает на элемент, стоящий на I пози- ций до элемента, указываемого PA, а PA+I на элемент, стоящий на I позиций после. Таким образ