5.3. Еще об аргументах функций
В главе 2 мы уже обсуждали тот факт, что аргументы функций передаются по значению, т.е. вызванная функция получает свою временную копию каждого аргумента, а не его адрес. Это означает, что вызванная функция не может воздействовать на исходный аргумент в вызывающей функции. Внутри функции каждый аргумент по существу является локальной переменной, которая инициализируется тем значением, с которым к этой функции обратились.
Если в качестве аргумента функции выступает имя массива, то передается адрес начала этого массива; сами элементы не копируются. Функция может изменять элементы массива, используя индексацию и адрес начала. Таким образом, массив передается по ссылке. В главе 6 мы обсудим, как использование указателей позволяет функциям воздействовать на отличные от массивов переменные в вызывающих функциях.
Между прочим, не существует полностью удовлетворительного способа написания переносимой функции с переменным числом аргументов. Дело в том, что нет переносимого способа, с помощью которого вызванная функция могла бы определить, сколько аргументов было фактически передано ей в данном обращении. Таким образом, вы, например, не можете написать действительно переносимую функцию, которая будет вычислять максимум от произвольного числа аргументов, как делают встроенные функции MAX в ФОРТРАНЕ и PL/1.
Обычно со случаем переменного числа аргументов безопасно иметь дело, если вызванная функция не использует аргументов, которые ей на самом деле не были переданы, и если типы согласуются. Самая распространенная в языке «C» функция с переменным числом – это printf. Она получает из первого аргумента информацию, позволяющую определить количество остальных аргументов и их типы. Функция printf работает совершенно неправильно, если вызывающая функция передает ей недостаточное количество аргументов, или если их типы не согласуются с типами, указанными в первом аргументе. Эта функция не является переносимой и должна модифицироваться при использовании в различных условиях.
Если же типы аргументов известны, то конец списка аргументов можно отметить, используя какое-то соглашение; например, считая, что некоторое специальное значение аргумента (часто нуль или –1) является признаком конца аргументов.
Программа на языке «C» состоит из набора внешних объектов, которые являются либо переменными, либо функциями. Термин «внешний» используется главным образом в противопоставление термину «внутренний», которым описываются аргументы и автоматические переменные, определенные внутри функций. Внешние переменные определены вне какой-либо функции и, таким образом, потенциально доступны для многих функций. Сами функции всегда являются внешними, потому что правила языка «C» не разрешают определять одни функции внутри других. По умолчанию внешние переменные являются также и «глобальными», так что все ссылки на такую переменную, использующие одно и то же имя (даже из функций, скомпилированных независимо), будут ссылками на одно и то же. В этом смысле внешние переменные аналогичны переменным COМMON в ФОРТРАНЕ и EXTERNAL в PL/1. Позднее мы покажем, как определить внешние переменные и функции таким образом, чтобы они были доступны не глобально, а только в пределах одного исходного файла.
В силу своей глобальной доступности внешние переменные предоставляют другую, отличную от аргументов и возвращаемых значений, возможность для обмена данными между функциями. Если имя внешней переменной каким-либо образом описано, то любая функция имеет доступ к этой переменной, ссылаясь к ней по этому имени.
В случаях, когда связь между функциями осуществляется с помощью большого числа переменных, внешние переменные оказываются более удобными и эффективными, чем использование длинных списков аргументов. Как, однако, отмечалось в главе 2, это соображение следует использовать с определенной осторожностью, так как оно может плохо отразиться на структуре программ и приводить к программам с большим числом связей по данным между функциями.
Вторая причина использования внешних переменных связана с инициализацией. В частности, внешние массивы могут быть инициализированы, а автоматические – нет. Мы рассмотрим вопрос об инициализации в конце этой главы.
Третья причина использования внешних переменных обусловлена их областью действия и временем существования. Автоматические переменные являются внутренними по отношению к функциям; они возникают при входе в функцию и исчезают при выходе из нее. Внешние переменные, напротив, существуют постоянно. Они не появляются и не исчезают, так что могут сохранять свои значения в период от одного обращения к функции до другого. В силу этого, если две функции используют некоторые общие данные, причем ни одна из них не обращается к другой, то часто наиболее удобным оказывается хранить эти общие данные в виде внешних переменных, а не передавать их в функцию и обратно с помощью аргументов.
Давайте продолжим обсуждение этого вопроса на большом примере. Задача будет состоять в написании другой программы для калькулятора, лучшей, чем предыдущая. Здесь допускаются операции +, -, ´, / и знак = (для выдачи ответа). Вместо инфиксного представления калькулятор будет использовать обратную польскую нотацию, поскольку ее несколько легче реализовать. В обратной польской нотации знак следует за операндами; инфиксное выражение типа:
(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.
Пример 5-4. Перевод этой схемы в программу достаточно прост. Ведущая программа является по существу большим переключателем по типу операции или операнду; это, по-видимому, более характерное применение переключателя, чем то, которое было продемонстрировано в главе 5.
#define maxop 20 // Макс. размер операнда, оператора
#define number '0' // Признак числа
#define toobig '9' // Сигнал, что строка велика
main() // Калькулятор в обратной польской нотации
{
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("Ошибка: деление на 0\n");
break;
case '=':
printf("\t%f\n",push(pop()));
break;
case 'c':
clear();
break;
case toobig:
printf("%.20s ... слишком длинная! \n",s);
break;
default:
printf("Неизвестная операция: %s\n",s);
break;
}
}
#define maxval 100 // Максимальная глубина стека
int sp = 0; // Свободная позиция стека
double val[maxval]; // Стек
double push(double f) // Положить значение f в стек
{
if (sp < maxval)
return(val[sp++] = f);
else
{
printf("Ошибка: стек переполнен \n");
clear();
return(0);
}
}
double pop()// Взять из стека и выдать как результат
{
if (sp > 0)
return(val[--sp]);
else
{
printf("Ошибка: стек пуст \n");
clear();
return(0);
}
}
void clear(void) // Очистить стек
{
sp=0;
}
Команда «с» очищает стек с помощью функции clear, которая также используется в случае ошибки функциями push и pop. К функции getop мы очень скоро вернемся.
Как уже говорилось в главе 2, переменная является внешней, если она определена вне тела какой бы то ни было функции. Поэтому стек и указатель стека, которые должны использоваться функциями push, pop и clear, определены вне этих трех функций. Но сама функция main не ссылается ни к стеку, ни к указателю стека – их участие тщательно замаскировано. В силу этого часть программы, соответствующая операции «=» , использует конструкцию:
push(pop());
для того, чтобы проанализировать верхний элемент стека, не изменяя его.
Отметим также, что, так как операции «+» и «´» коммутативны, порядок, в котором объединяются извлеченные операнды, несущественен, но в случае операций «–» и «/» необходимо различать левый и правый операнды.