от 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. (Полезное
соглашение состоит в том, что символ -, стоящий в начале или
конце, воспринимается буквально).
Как уже отмечалось в главе 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тоа, который имеет три, а не два аргу-
мента. Третий аргумент - минимальная ширина поля; преобразо-
ванное число должно, если это необходимо, дополняться слева
пробелами, так чтобы оно имело достаточную ширину.
Иногда бывает удобным иметь возможность управлять выхо-
дом из цикла иначе, чем проверкой условия в начале или в
конце. Оператор 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'))
;
...
}
Это уступает предыдущему варианту, так как проверка стано-
вится труднее для понимания. Проверок, которые требуют пе-
реплетения &&, \!\!, ! И круглых скобок, по возможности сле-
дует избегать.
Оператор 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).
В языке "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, то
весьма умеренно.
Функции разбивают большие вычислительные задачи на ма-
ленькие подзадачи и позволяют использовать в работе то, что
уже сделано другими, а не начинать каждый раз с пустого мес-
та. Соответствующие функции часто могут скрывать в себе де-
тали проводимых в разных частях программы операций, знать
которые нет необходимости, проясняя тем самым всю программу,
как целое, и облегчая мучения при внесении изменений.
Язык "C" разрабатывался со стремлением сделать функции
эффективными и удобными для использования; "C"-программы
обычно состоят из большого числа маленьких функций, а не из
нескольких больших. Программа может размещаться в одном или
нескольких исходных файлах любым удобным образом; исходные
файлы могут компилироваться отдельно и загружаться вместе
наряду со скомпилированными ранее функциями из библиотек. Мы
здесь не будем вдаваться в детали этого процесса, поскольку
они зависят от используемой системы.
Большинство программистов хорошо знакомы с "библиотечны-
ми" функциями для ввода и вывода /GETCHAR , PUTCHAR/ и для
численных расчетов /SIN, COS, SQRT/. В этой главе мы сообщим
больше о написании новых функций.
Для начала давайте разработаем и составим программу пе-
чати каждой строки ввода, которая содержит определенную ком-
бинацию символов. /Это - специальный случай утилиты 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.
До сих пор ни одна из наших программ не содержала како-
го-либо описания типа функции. Дело в том, что по умолчанию
функция неявно описывается своим появлением в выражении или
операторе, как, например, в
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' и пока-
затель экспоненты, возможно со знаком.
В главе 1 мы уже обсуждали тот факт , что аргументы фун-
кций передаются по значению, т.е. вызванная функция получает
свою временную копию каждого аргумента, а не его адрес. это
означает, что вызванная функция не может воздействовать на
исходный аргумент в вызывающей функции. Внутри функции каж-
дый аргумент по существу является локальной переменной, ко-
торая инициализируется тем значением, с которым к этой функ-
ции обратились.
Если в качестве аргумента функции выступает имя массива,
то передается адрес начала этого массива; сами элементы не
копируются. Функция может изменять элементы массива, исполь-
зуя индексацию и адрес начала. Таким образом, массив переда-
ется по ссылке. В главе 5 мы обсудим, как использование ука-
зателей позволяет функциям воздействовать на отличные от
массивов переменные в вызывающих функциях.
Между прочим, несуществует полностью удовлетворительного
способа написания переносимой функции с переменным числом
аргументов. Дело в том, что нет переносимого способа, с по-
мощью которого вызванная функция могла бы определить, сколь-
ко аргументов было фактически передано ей в данном обраще-
нии. Таким образом, вы, например, не можете написать дейст-
вительно переносимую функцию, которая будет вычислять макси-
мум от произвольного числа аргументов, как делают встроенные
функции MAX в фортране и PL/1.
Обычно со случаем переменного числа аргументов безопасно
иметь дело, если вызванная функция не использует аргументов,
которые ей на самом деле не были переданы, и если типы сог-
ласуются. Самая распространенная в языке "C" функция с пере-
менным числом - PRINTF . Она получает из первого аргумента
информацию, позволяющую определить количество остальных ар-
гументов и их типы. Функция PRINTF работает совершенно неп-
равильно, если вызывающая функция передает ей недостаточное
количество аргументов, или если их типы не согласуются с ти-
пами, указанными в первом аргументе. Эта функция не является
переносимой и должна модифицироваться при использовании в
различных условиях.
Если же типы аргументов известны, то конец списка аргу-
ментов можно отметить, используя какое-то соглашение; напри-
мер, считая, что некоторое специальное значение аргумента
(часто нуль) является признаком конца аргументов.
Программа на языке "C" состоит из набора внешних объек-
тов, которые являются либо переменными, либо функциями. Тер-
мин "внешний" используется главным образом в противопостав-
ление термину "внутренний", которым описываются аргументы и
автоматические переменные, определенные внурти функций.
Внешние переменные определены вне какой-либо функции и, та-
ким образом, потенциально доступны для многих функций. Сами
функции всегда являются внешними, потому что правила языка
"C" не разрешают определять одни функции внутри других. По
умолчанию внешние переменные являются также и "глобальными",
так что все ссылки на такую переменную, использующие одно и
то же имя (даже из функций, скомпилированных независимо),
будут ссылками на одно и то же. В этом смысле внешние пере-
менные аналогичны переменным COмMON в фортране и EXTERNAL в
PL/1. Позднее мы покажем, как определить внешние переменные
и функции таким образом, чтобы они были доступны не глобаль-
но, а только в пределах одного исходного файла.
В силу своей глобальной доступности внешние переменные
предоставляют другую, отличную от аргументов и возвращаемых
значений, возможность для обмена данными между функциями.
Если имя внешней переменной каким-либо образом описано, то
любая функция имеет доступ к этой переменной, ссылаясь к ней
по этому имени.
В случаях, когда связь между функциями осуществляется с
помощью большого числа переменных, внешние переменные оказы-
ваются более удобными и эффективными, чем использование
длинных списков аргументов. Как, однако, отмечалось в главе
1, это соображение следует использовать с определенной осто-
рожностью, так как оно может плохо отразиться на структуре
программ и приводить к программам с большим числом связей по
данным между функциями.
Вторая причина использования внешних переменных связана
с инициализацией. В частности, внешние массивы могут быть
инициализированы а автоматические нет. Мы рассмотрим вопрос
об инициализации в конце этой главы.
Третья причина использования внешних переменных обуслов-
лена их областью действия и временем существования. Автома-
тические переменные являются внутренними по отношению к фун-
кциям; они возникают при входе в функцию и исчезают при вы-
ходе из нее. Внешние переменные, напротив, существуют посто-
янно. Они не появляютя и не исчезают, так что могут сохра-
нять свои значения в период от одного обращения к функции до
другого. В силу этого, если две функции используют некоторые
общие данные, причем ни одна из них не обращается к другой ,
то часто наиболее удобным оказывается хранить эти общие дан-
ные в виде внешних переменных, а не передавать их в функцию
и обратно с помощью аргументов.
Давайте продолжим обсуждение этого вопроса на большом
примере. Задача будет состоять в написании другой программы
для калькулятора, лучшей,чем предыдущая. Здесь допускаются
операции +,-,*,/ и знак = (для выдачи ответа).вместо инфикс-
ного представления калькулятор будет использовать обратную
польскую нотацию,поскольку ее несколько легче реализовать.в
обратной польской нотации знак следует за операндами; инфик-
нулю. Средний цикл сравнивает каждую пару элементов, разде-
ленных на величину интервала; самый внутренний цикл перес-
тавляет любую неупорядоченную пару. Так как интервал в конце
концов сводится к единице, все элементы в результате упоря-
дочиваются правильно. Отметим, что в силу общности конструк-
ции 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. (Полезное
соглашение состоит в том, что символ -, стоящий в начале или
конце, воспринимается буквально).
Как уже отмечалось в главе 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тоа, который имеет три, а не два аргу-
мента. Третий аргумент - минимальная ширина поля; преобразо-
ванное число должно, если это необходимо, дополняться слева
пробелами, так чтобы оно имело достаточную ширину.
Иногда бывает удобным иметь возможность управлять выхо-
дом из цикла иначе, чем проверкой условия в начале или в
конце. Оператор 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'))
;
...
}
Это уступает предыдущему варианту, так как проверка стано-
вится труднее для понимания. Проверок, которые требуют пе-
реплетения &&, \!\!, ! И круглых скобок, по возможности сле-
дует избегать.
Оператор 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).
В языке "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, то
весьма умеренно.
Функции разбивают большие вычислительные задачи на ма-
ленькие подзадачи и позволяют использовать в работе то, что
уже сделано другими, а не начинать каждый раз с пустого мес-
та. Соответствующие функции часто могут скрывать в себе де-
тали проводимых в разных частях программы операций, знать
которые нет необходимости, проясняя тем самым всю программу,
как целое, и облегчая мучения при внесении изменений.
Язык "C" разрабатывался со стремлением сделать функции
эффективными и удобными для использования; "C"-программы
обычно состоят из большого числа маленьких функций, а не из
нескольких больших. Программа может размещаться в одном или
нескольких исходных файлах любым удобным образом; исходные
файлы могут компилироваться отдельно и загружаться вместе
наряду со скомпилированными ранее функциями из библиотек. Мы
здесь не будем вдаваться в детали этого процесса, поскольку
они зависят от используемой системы.
Большинство программистов хорошо знакомы с "библиотечны-
ми" функциями для ввода и вывода /GETCHAR , PUTCHAR/ и для
численных расчетов /SIN, COS, SQRT/. В этой главе мы сообщим
больше о написании новых функций.
Для начала давайте разработаем и составим программу пе-
чати каждой строки ввода, которая содержит определенную ком-
бинацию символов. /Это - специальный случай утилиты 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.
До сих пор ни одна из наших программ не содержала како-
го-либо описания типа функции. Дело в том, что по умолчанию
функция неявно описывается своим появлением в выражении или
операторе, как, например, в
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' и пока-
затель экспоненты, возможно со знаком.
В главе 1 мы уже обсуждали тот факт , что аргументы фун-
кций передаются по значению, т.е. вызванная функция получает
свою временную копию каждого аргумента, а не его адрес. это
означает, что вызванная функция не может воздействовать на
исходный аргумент в вызывающей функции. Внутри функции каж-
дый аргумент по существу является локальной переменной, ко-
торая инициализируется тем значением, с которым к этой функ-
ции обратились.
Если в качестве аргумента функции выступает имя массива,
то передается адрес начала этого массива; сами элементы не
копируются. Функция может изменять элементы массива, исполь-
зуя индексацию и адрес начала. Таким образом, массив переда-
ется по ссылке. В главе 5 мы обсудим, как использование ука-
зателей позволяет функциям воздействовать на отличные от
массивов переменные в вызывающих функциях.
Между прочим, несуществует полностью удовлетворительного
способа написания переносимой функции с переменным числом
аргументов. Дело в том, что нет переносимого способа, с по-
мощью которого вызванная функция могла бы определить, сколь-
ко аргументов было фактически передано ей в данном обраще-
нии. Таким образом, вы, например, не можете написать дейст-
вительно переносимую функцию, которая будет вычислять макси-
мум от произвольного числа аргументов, как делают встроенные
функции MAX в фортране и PL/1.
Обычно со случаем переменного числа аргументов безопасно
иметь дело, если вызванная функция не использует аргументов,
которые ей на самом деле не были переданы, и если типы сог-
ласуются. Самая распространенная в языке "C" функция с пере-
менным числом - PRINTF . Она получает из первого аргумента
информацию, позволяющую определить количество остальных ар-
гументов и их типы. Функция PRINTF работает совершенно неп-
равильно, если вызывающая функция передает ей недостаточное
количество аргументов, или если их типы не согласуются с ти-
пами, указанными в первом аргументе. Эта функция не является
переносимой и должна модифицироваться при использовании в
различных условиях.
Если же типы аргументов известны, то конец списка аргу-
ментов можно отметить, используя какое-то соглашение; напри-
мер, считая, что некоторое специальное значение аргумента
(часто нуль) является признаком конца аргументов.
Программа на языке "C" состоит из набора внешних объек-
тов, которые являются либо переменными, либо функциями. Тер-
мин "внешний" используется главным образом в противопостав-
ление термину "внутренний", которым описываются аргументы и
автоматические переменные, определенные внурти функций.
Внешние переменные определены вне какой-либо функции и, та-
ким образом, потенциально доступны для многих функций. Сами
функции всегда являются внешними, потому что правила языка
"C" не разрешают определять одни функции внутри других. По
умолчанию внешние переменные являются также и "глобальными",
так что все ссылки на такую переменную, использующие одно и
то же имя (даже из функций, скомпилированных независимо),
будут ссылками на одно и то же. В этом смысле внешние пере-
менные аналогичны переменным COмMON в фортране и EXTERNAL в
PL/1. Позднее мы покажем, как определить внешние переменные
и функции таким образом, чтобы они были доступны не глобаль-
но, а только в пределах одного исходного файла.
В силу своей глобальной доступности внешние переменные
предоставляют другую, отличную от аргументов и возвращаемых
значений, возможность для обмена данными между функциями.
Если имя внешней переменной каким-либо образом описано, то
любая функция имеет доступ к этой переменной, ссылаясь к ней
по этому имени.
В случаях, когда связь между функциями осуществляется с
помощью большого числа переменных, внешние переменные оказы-
ваются более удобными и эффективными, чем использование
длинных списков аргументов. Как, однако, отмечалось в главе
1, это соображение следует использовать с определенной осто-
рожностью, так как оно может плохо отразиться на структуре
программ и приводить к программам с большим числом связей по
данным между функциями.
Вторая причина использования внешних переменных связана
с инициализацией. В частности, внешние массивы могут быть
инициализированы а автоматические нет. Мы рассмотрим вопрос
об инициализации в конце этой главы.
Третья причина использования внешних переменных обуслов-
лена их областью действия и временем существования. Автома-
тические переменные являются внутренними по отношению к фун-
кциям; они возникают при входе в функцию и исчезают при вы-
ходе из нее. Внешние переменные, напротив, существуют посто-
янно. Они не появляютя и не исчезают, так что могут сохра-
нять свои значения в период от одного обращения к функции до
другого. В силу этого, если две функции используют некоторые
общие данные, причем ни одна из них не обращается к другой ,
то часто наиболее удобным оказывается хранить эти общие дан-
ные в виде внешних переменных, а не передавать их в функцию
и обратно с помощью аргументов.
Давайте продолжим обсуждение этого вопроса на большом
примере. Задача будет состоять в написании другой программы
для калькулятора, лучшей,чем предыдущая. Здесь допускаются
операции +,-,*,/ и знак = (для выдачи ответа).вместо инфикс-
ного представления калькулятор будет использовать обратную
польскую нотацию,поскольку ее несколько легче реализовать.в
обратной польской нотации знак следует за операндами; инфик-