Упражнение 5-3. Приведенная основная схема допускает непосредственное расширение возможностей калькулятора. Включите операцию деления по модулю «%» и унарный минус. Включите команду «стереть», которая удаляет верхний элемент стека. Введите команды для работы с переменными (это просто, если имена переменных будут состоять из одной буквы из имеющихся двадцати шести букв).
5.5. Правила, определяющие область действия
Функции и внешние переменные, входящие в состав «C»-программы, не обязаны компилироваться одновременно; программа на исходном языке может располагаться в нескольких файлах, и ранее скомпилированные процедуры могут загружаться из библиотек. Два вопроса представляют интерес:
1. Как следует составлять описания, чтобы переменные правильно воспринимались во время компиляции?
2. Как следует составлять описания, чтобы обеспечить правильную связь частей программы при загрузке?
Областью действия (или видимости) имени является та часть программы, в которой это имя определено. Для автоматической переменной, описанной в начале функции, областью действия является та функция, в которой описано имя этой переменной, а переменные из разных функций, имеющие одинаковое имя, считаются не относящимися друг к другу. Это же справедливо и для аргументов функций.
Область действия внешней переменной простирается от точки, в которой она объявлена в исходном файле, до конца этого файла. Например, если 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; // Указатель стека
double val[maxval]; // Максимальная глубина стека
(в файле 2):
extern int sp;
extern double val[];
double push(f) {...}
double pop() {...}
clear() {...}
так как описания extern в файле 1 находятся выше и вне трех указанных функций, они относятся ко всем ним; одного набора описаний достаточно для всего файла 2.
Для программ большого размера (обсуждаемая позже в этой главе) возможность включения файлов, #include, позволяет иметь во всей программе только одну копию описаний extern и вставлять ее в каждый исходный файл во время его компиляции.
Обратимся теперь к функции getop, выбирающей из файла ввода следующую операцию или операнд. Основная задача проста: пропустить пробелы, знаки табуляции и новые строки. Если следующий символ отличен от цифры и десятичной точки, то возвратить его. В противном случае собрать строку цифр (она может включать десятичную точку) и возвратить number как сигнал о том, что выбрано число.
Пример 5-5. Процедура существенно усложняется, если стремиться правильно обрабатывать ситуацию, когда вводимое число оказывается слишком длинным. Функция getop считывает цифры подряд (возможно с десятичной точкой) и запоминает их, пока последовательность не прерывается. Если при этом не происходит переполнения, то функция возвращает number и строку цифр. Если же число оказывается слишком длинным, то getop отбрасывает остальную часть строки из файла ввода, так что пользователь может просто перепечатать эту строку с места ошибки; функция возвращает toobig как сигнал о переполнении.
// Получить следующий оператор или операнд
getop(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 == '.')
{ // Накапливаем дробную часть
if (i < lim)
s[i] = c;
for(i++;(c=getchar()) >='0' && c<='9';i++)
if (i < lim)
s[i] =c;
}
if (i < lim)
{ // Число правильное
ungetch(c);
s[i] = '\0';
return (number);
}
else
{ // Эта строчка слишком длинная
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]; // Буфер для ungetch
int bufp = 0; // След. Свободная позиция в буфере
// Взять (возможно возвращенный) символ
getch()
{
return((bufp > 0) ? buf[--bufp] : getchar());
}
// Вернуть символ на ввод
ungetch(int c)
{
if (bufp > bufsize)
printf("ungetch: слишком много символов \n");
else
buf [bufp++] = c;
}
Мы использовали для хранения возвращаемых символов массив, а не отдельный символ, потому что такая общность может пригодиться в дальнейшем.
Упражнение 5-4. Напишите функцию ungets(s), которая будет возвращать во ввод целую строку. Должна ли ungets иметь дело с buf и bufp или она может просто использовать ungets?
Упражнение 5-5. Предположите, что может возвращаться только один символ. Измените getch и ungetch соответствующим образом.
Упражнение 5-6. Наши функции getch и ungetch не обеспечивают обработку возвращенного символа eof переносимым образом. Решите, каким свойством должны обладать эти функции, если возвращается eof, и реализуйте ваши выводы.
Статические переменные представляют собой третий класс памяти, в дополнении к автоматическим переменным и extern, с которыми мы уже встречались. Статические переменные могут быть либо внутренними, либо внешними. Внутренние статические переменные точно так же, как и автоматические, являются локальными для некоторой функции, но, в отличие от автоматических, они остаются существовать, а не появляются и исчезают вместе с обращением к этой функции. это означает, что внутренние статические переменные обеспечивают постоянное, недоступное извне хранение внутри функции. Символьные строки, появляющиеся внутри функции, как, например, аргументы printf , являются внутренними статическими.
Внешние статические переменные определены в остальной части того исходного файла, в котором они описаны, но не в каком-либо другом файле. Таким образом, они дают способ скрывать имена, подобные buf и bufp в комбинации getch-ungetch, которые в силу их совместного использования должны быть внешними, но все же не доступными для пользователей getch и ungetch, чтобы исключалась возможность конфликта.
Если эти две функции и две переменные объединить в одном файле следующим образом:
static char buf[bufsize];// Буфер для ungetch
static int bufp=0; // Свободная позиция в буфере
getch() {...}
ungetch() {...}
то никакая другая функция не будет в состоянии обратиться к buf и bufp; фактически, они не будут вступать в конфликт с такими же именами из других файлов той же самой программы.
Статическая память, как внутренняя, так и внешняя, специфицируется словом static, стоящим перед обычным описанием. Переменная является внешней, если она описана вне какой бы то ни было функции, и внутренней, если она описана внутри некоторой функции.
Нормально функции являются внешними объектами; их имена известны глобально. возможно, однако, объявить функцию как static; тогда ее имя становится неизвестным вне файла, в котором оно описано.