Начальная страница

Kernighan, B. W. and Ritchie, D. M. "The 'C' Programming Language"; Chapter 4

Функции и структура программ.

Функции разбивают большие вычислительные задачи на маленькие подзадачии позволяют использовать в работе то, что уже сделано другими, а неначинать каждый раз с пустого места. Соответствующие функции частомогут скрывать в себе детали проводимых в разных частях программыопераций, знать которые нет необходимости, проясняя тем самым всюпрограмму, как целое, и облегчая мучения при внесении изменений.

Язык "C" разрабатывался со стремлением сделать функции эффективнымии удобными для использования; "C"-программы обычно состоят из большогочисла маленьких функций, а не из нескольких больших. Программа можетразмещаться в одном или нескольких исходных файлах любым удобнымобразом; исходные файлы могут компилироваться отдельно и загружатьсявместе наряду со скомпилированными ранее функциями из библиотек.Мы здесь не будем вдаваться в детали этого процесса, поскольку онизависят от используемой системы.

Большинство программистов хорошо знакомы с "библиотечными" функциямидля ввода и вывода /getchar, putchar/ и для численных расчетов/sin, cos, sqrt/. В этой главе мы сообщим больше о написании новыхфункций.

Содержание

4.1. Основные сведения.
4.2. Функции, возвращающие нецелые значения.
4.3. Еще об аргументах функций
4.4. Внешние переменные.
4.5. Правила, определяющие область действия.
4.6. Статические переменные.
4.7. Регистровые переменные.
4.8. Блочная структура.
4.9. Инициализация.
4.10. Рекурсия.
4.11. Препроцессор языка 'C'
4.11.1. Включение файлов
4.11.2. Макроподстановка

Основные сведения.

Для начала давайте разработаем и составим программу печати каждойстроки ввода, которая содержит определенную комбинацию символов.(Это - специальный случай утилиты grep системы "UNIX").Например, при поиске комбинации "the" в наборе строк

now is the timefor all goodmen to come to the aidof their party
в качестве выхода получим
now is the timemen to come to the aidof their party

Основная схема выполнения задания четко разделяется на три части:

while (имеется еще строка)	if (строка содержит нужную комбинацию)		вывод этой строки

Конечно, возможно запрограммировать все действия в виде одной основнойпроцедуры, но лучше использовать естественную структуру задачи ипредставить каждую часть в виде отдельной функции. С тремя маленькимикусками легче иметь дело, чем с одним большим, потому что отдельныене относящиеся к существу дела детали можно включить в функции иуменьшить возможность нежелательных взаимодействий. Кроме того, этикуски могут оказаться полезными сами по себе.

"Пока имеется еще строка" - этоgetline, функция, которую мызапрограммировали вглаве 1,а "вывод этой строки" - это функция printf,которую уже кто-то подготовил для нас. Это значит, что нам осталосьтолько написать процедуру для определения, содержит ли строка даннуюкомбинацию символов или нет. Мы можем решить эту проблему,позаимствовав разработку из pl/1: функцияindex(s,t) возвращает позицию,или индекс, строки s, где начинается строка t, и -1, если s не содержитt. В качестве начальной позиции мы используем 0, а не 1, потому что вязыке "C" массивы начинаются с позиции нуль. Когда нам в дальнейшемпонадобится проверять на совпадение более сложные конструкции, нампридется заменить только функцию index; остальная часть программыостанется той же самой.

После того, как мы потратили столько усилий на разработку, написаниепрограммы в деталях не представляет затруднений. Ниже приводитсяцеликом вся программа, так что вы можете видеть, как соединяютсявместе отдельные части. Комбинация символов, по которой производитсяпоиск, выступает пока в качестве символьной строки в аргументе функцииindex, что не является самым общим механизмом. Мы скоро вернемся кобсуждению вопроса об инициализации символьных массивов и вглаве 5покажем, как сделать комбинацию символов параметром, которомуприсваивается значение в ходе выполнения программы. Программа такжесодержит новый вариант функции getline; вам может оказаться полезнымсравнить его с вариантом из главы 1.

#define maxline 1000main(){				/* 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 может не быть вообще никакоговыражения; в этом случае в вызывающую программу не передается никакогозначения. Управление также возвращется в вызывающую программу безпередачи какого-либо значения и в том случае, когда при выполнении мы"проваливаемся" на конец функции, достигая закрывающейся правойфигурной скобки. Если функция возвращает значение из одного места и невозвращает никакого значения из другого места, это не являетсянезаконным, но может быть признаком каких-то неприятностей. В любомслучае "значением" функции, которая не возвращает значения, несомненнобудет мусор. Отладочная программа lint проверяет такие ошибки.

Механика компиляции и загрузки "C"-программ, расположенных в несколькихисходных файлах, меняется от системы к системе. В системе "UNIX",например, эту работу выполняет команда 'cc', упомянутая вглаве 1.Предположим, что три функции находятся в трех различных файлах с именамиmain.c, getline.c и index.c . Тогда команда

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' использует соглашение о наименовании c ".c" и ".o" длятого, чтобы отличить исходные файлы от об'ектных.

Упражнение 4-1.
Составьте программу для функции rindex(s,t), котораявозвращает позицию самого правого вхождения t в sи -1, если s не содержит t.

Функции, возвращающие нецелые значения.

До сих пор ни одна из наших программ не содержала какого-либо описаниятипа функции. Дело в том, что по умолчанию функция неявно описываетсясвоим появлением в выражении или операторе, как, например, в

while (getline(line, maxline) > 0)

Если некоторое имя, которое не было описано ранее, появляется ввыражении и за ним следует левая круглая скобка, то оно по контекстусчитается именем некоторой функции. Кроме того, по умолчаниюпредполагается, что эта функция возвращает значение типа int. Так как ввыражениях char преобразуется в int, то нет необходимости описыватьфункции, возвращающие char. Эти предположения покрывают большинствослучаев, включая все приведенные до сих пор примеры.

Но что происходит, если функция должна возвратить значение какого-тодругого типа ? Многие численные функции, такие как sqrt, sin и cosвозвращают double; другие специальные функции возвращают значениядругих типов. Чтобы показать, как поступать в этом случае, давайтенапишем и используем функцию atof(s),которая преобразует строку sв эквивалентное ей плавающее число двойной точности. Функция atofявляется расширениемatoi, варианты которой мы написали вглавах 2 и 3;она обрабатывает необязательно знак и десятичную точку, а также целуюи дробную часть, каждая из которых может как присутствовать, так иотсутствовать./эта процедура преобразования ввода не очень высокогокачества; иначе она бы заняла больше места, чем нам хотелось бы/.

Во-первых, сама atof должна описывать тип возвращаемого ею значения,поскольку он отличен от int. Так как в выражениях тип floatпреобразуется в double, то нет никакого смысла в том, чтобыatof возвращала float; мы можем с равным успехом воспользоватьсядополнительной точностью, так что мы полагаем, что возвращаемое значениетипа double. Имя типа должно стоять перед именем функции, какпоказывается ниже:

doubleatof(s)				/* convert string s tо				 * double */	char            s[];{	double          val, power;	int             i, sign;	/* skip white space */	for (i = 0;	     s[i] == ' ' || s[i] == '\n' || s[i] == '\t';	     i++);	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 100main(){				/* 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 */	khar            s[];{	double          atof();	return (atof(s));}
Обратите внимание на структуру описаний и оператор return. Значениевыражения в
return (выражение);
всегда преобразуется к типу функции перед выполнением самоговозвращения. Поэтому при появлении в операторе return значениефункции atof, имеющее тип double, автоматически преобразуется в int,поскольку функция atoi возвращает int. (как обсуждалось вглаве 2,преобразование значения с плавающей точкой к типу int осуществляетсяпосредством отбрасывания дробной части).
Упражнение 4-2.
Расширьте atof таким образом, чтобы она могла работать с числами вида
123.45e-6
где за числом с плавающей точкой может следовать 'e' и показательэкспоненты, возможно со знаком.

Еще об аргументах функций

В главе 1мы уже обсуждали тот факт, что аргументы функций передаютсяпо значению, т.е. вызванная функция получает свою временную копиюкаждого аргумента, а не его адрес. Это означает, что вызванная функцияне может воздействовать на исходный аргумент в вызывающей функции.Внутри функции каждый аргумент по существу является локальнойпеременной, которая инициализируется тем значением, с которым к этойфункции обратились.

Если в качестве аргумента функции выступает имя массива, то передаетсяадрес начала этого массива; сами элементы не копируются. Функция можетизменять элементы массива, используя индексацию и адрес начала. Такимобразом, массив передается по ссылке. Вглаве 5 мы обсудим, какиспользование указателей позволяет функциям воздействовать на отличныеот массивов переменные в вызывающих функциях.

Между прочим, несуществует полностью удовлетворительного способанаписания переносимой функции с переменным числом аргументов. Дело втом, что нет переносимого способа, с помощью которого вызванная функциямогла бы определить, сколько аргументов было фактически передано ей вданном обращении. Таким образом, вы, например, не можете написатьдействительно переносимую функцию, которая будет вычислять максимум отпроизвольного числа аргументов, как делают встроенные функции мах вфортране и pl/1.

Обычно со случаем переменного числа аргументов безопасно иметь дело,если вызванная функция не использует аргументов, которые ей на самомделе не были переданы, и если типы согласуются. Самая распространеннаяв языке "C" функция с переменным числом - printf . Она получает изпервого аргумента информацию, позволяющую определить количествоостальных аргументов и их типы. Функция printf работает совершеннонеправильно, если вызывающая функция передает ей недостаточноеколичество аргументов, или если их типы не согласуются с типами,указанными в первом аргументе. Эта функция не является переносимой идолжна модифицироваться при использовании в различных условиях.

Если же типы аргументов известны, то конец списка аргументов можноотметить, используя какоe-то соглашение; например, считая, что некотороеспециальное значение аргумента (часто нуль) является признаком концааргументов.

Внешние переменные.

Программа на языке "C" состоит из набора внешних об'ектов, которыеявляются либо переменными, либо функциями. Термин "внешний" используетсяглавным образом в противопоставление термину "внутренний", которымописываются аргументы и автоматические переменные, определенные внуртифункций. Внешние переменные определены вне какой-либо функции и, такимобразом, потенциально доступны для многих функций. Сами функции всегдаявляются внешними, потому что правила языка "C" не разрешают определятьодни функции внутри других. По умолчанию внешние переменные являютсятакже и "глобальными", так что все ссылки на такую переменную,использующие одно и то же имя (даже из функций, скомпилированныхнезависимо), будут ссылками на одно и то же. В этом смысле внешниепеременные аналогичны переменным common в фортране и external в pl/1.Позднее мы покажем, как определить внешние переменные и функции такимобразом, чтобы они были доступны не глобально, а только в пределаходного исходного файла.

В силу своей глобальной доступности внешние переменные предоставляютдругую, отличную от аргументов и возвращаемых значений, возможностьдля обмена данными между функциями. Еслиимя внешней переменной каким-либо образом описано, то любая функцияимеет доступ к этой переменной, ссылаясь к ней по этому имени.

В случаях, когда связь между функциями осуществляется с помощью большогочисла переменных, внешние переменные оказываются более удобными иэффективными, чем использование длинных списков аргументов. Как, однако,отмечалось в главе 1,это соображение следует использовать сопределенной осторожностью, так как оно может плохо отразиться наструктуре программ и приводить к программам с большим числом связей поданным между функциями.

Вторая причина использования внешних переменных связана синициализацией. В частности, внешние массивы могут бытьинициализированыа автоматические нет. Мы рассмотрим вопрос об инициализации в конце этойглавы.

Третья причина использования внешних переменных обусловлена их областьюдействия и временем существования. Автоматические переменные являютсявнутренними по отношению к функциям; они возникают при входе в функциюи исчезают при выходе из нее. Внешние переменные, напротив, существуютпостоянно. Они не появляютя и не исчезают, так что могут сохранятьсвои значения в период от одного обращения к функции до другого.В силу этого, если две функции используют некоторые общие данные, причемни одна из них не обращается к другой, то часто наиболее удобнымоказывается хранить эти общие данные в виде внешних переменных, а непередавать их в функцию и обратно с помощью аргументов.

Давайте продолжим обсуждение этого вопроса на большом примере.Задача будет состоять в написании другой программыдля калькулятора,лучшей,чем предыдущая. Здесь допускаются операции +,-,*,/ и знак =(для выдачи ответа).вместо Инфиксного представления калькулятор будетиспользовать обратную польскую нотацию,поскольку ее несколько легчереализовать. Обратной польской нотации знак следует за операндами;инфиксное выражение типа

(1 - 2) * (4 + 5) =
записывается в виде
12-45+*=
Круглые скобки при этом не нужны.

Реализация оказывается весьма простой.каждый Операнд помещается в стек;когда поступает знак операции,нужное число операндов (два для бинарныхопераций) вынимается,к ним применяется операция и результат направляетсяобратно в стек.так В приведенном выше примере 1 и 2 помещаются в стеки затем заменяются их разностью, -1.после Этого 4 и 5 вводятся в стеки затем заменяются своей суммой,9.далее Числа -1 и 9 заменяются в стекена их произведение,равное -9.операция = печатает верхний элемент стека,не удаляя его (так что промежуточные вычисления могут быть проверены).

Сами операции помещения чисел в стек и их извлечения очень просты,но,в связи с включением в настоящую программу обнаружения ошибоки восстановления,они оказываются достаточно длинными. Поэтому лучшеоформить их в виде отдельных функций,чем повторять соответствующий текстповсюду в программе. Кроме того, нужна отдельная функция для выборкииз ввода следующей операции или операнда. Таким образом, структурапрограммы имеет вид:

while ( поступает операция или операнд, а не конец файла )	if ( число )		поместить его в стек	else if ( операция )		вынуть операнды из стека		выполнить операцию		поместить результат в стек	else		ошибка

Основной вопрос, который еще не был обсужден, заключается в том, гдепоместить стек, т. е. Какие процедуры смогут обращаться к немунепосредственно. Одна из таких возможностей состоит в помещении стекав main и передачи самого стека и текущей позиции в стеке функциям,работающим со стеком. Но функции main нет необходимости иметь делос переменными, управляющими стеком; ей естественно рассуждать втерминах помещения чисел в стек и извлечения их оттуда. В силу этогомы решили сделать стек и связанную с ним информацию внешними переменными,доступными функциям push (помещение в стек) и рор (извлечение изстека), но не main.

Перевод этой схемы в программу достаточно прост. Ведущая программаявляется по существу большим переключателем по типу операции илиоперанду; это, по-видимому, более характерное применеие переключателя,чем то, которое было продемонстрировано в главе 3.

#define maxop 20		/* max size of operand,				 * operator */#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 */doublepush(f)				/* push f onto value				 * stack */	double          f;{	if (sp < maxval)		return (val[sp++] = f);	else {		printf("error: stack full\n");		clear();		return (0);	}}doublepop(){				/* 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;}

Команда с очищает стек с помощью функции clear, которая такжеиспользуется в случае ошибки функциями push и рор. К функцииgetop мы очень скоро вернемся.

Как уже говорилось в главе 1, переменная является внешней, если онаопределена вне тела какой бы то ни было функции. Поэтому стек иуказатель стека, которые должны использоваться функциями push, рор иclear, определены вне этих трех функций. Но сама функция main нессылается ни к стеку, ни к указателю стека - их участие тщательнозамаскировано. В силу этого часть программы, соответствующая операции=, использует конструкцию

push(pop());
для того, чтобы проанализировать верхний элемент стека, не изменяя его.

Отметим также, что так как операции + и * коммутативны, порядок, вкотором об'единяются извлеченные операнды, несущественен, но в случаеопераций - и / необходимо различать левый и правый операнды.

Упражнение 4-3.
Приведенная основная схема допускает непосредственное расширениевозможностей калькулятора. Включите операцию деления по модулю /%/ иунарный минус. Включите команду "стереть", которая удаляет верхнийэлемент стека. Введите команды для работы с переменными. /это просто,если имена переменных будут состоять из одной буквы из имеющихсядвадцати шести букв/.

Правила, определяющие область действия.

Функции и внешние переменные, входящие в состав "C"-программы, необязаны компилироваться одновременно; программа на исходном языке можетрасполагаться в нескольких файлах, и ранее скомпилированные процедурымогут загружаться из библиотек. Два вопроса представляют интерес:

Как следует составлять описания, чтобы переменные правильновоспринимались во время компиляции?

Как следует составлять описания, чтобы обеспечить правильную связьчастей программы при загрузке?

Область действия

Областью действия имени является та часть программы, в которой это имяопределено. Для автоматической переменной, описанной в начале функции,областью действия является та функция, в которой описано имя этойпеременной, а переменные из разных функций, имеющие одинаковое имя,считаются не относящимися друг к другу. Это же справедливо и дляаргументов функций.

Область действия внешней переменной простирается от точки, в которойона об'явлена в исходном файле, до конца этого файла. Например, еслиval, sp, push, рор и clear определены в одном файле в порядке,указанном выше, а именно:

int             sp = 0;double          val[maxval];doublepush(f){	...}doublepop(){	...}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, рор и 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 100char            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, и реализуйте ваши выводы.

Статические переменные.

Статические переменные представляют собой третий класс памяти, вдополнении к автоматическим переменным и 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, рор и clear формируют модуль обработки стека; var и sp тожедолжны быть внешними статическими.

Регистровые переменные.

Четвертый и последний класс памяти называется регистровым.Описание 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 или указатель.

Блочная структура.

Язык "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;	...}
то появление х внутри функции f относится к внутренней переменной типаdouble, а вне f - к внешней целой переменной. Это же справедливо вотношении имен формальных параметров:
int             x;f(x)	double          x;{	...}
внутри функции f имя х относится к формальному параметру, а не к внешнейпеременной.

Инициализация.

Мы до сих пор уже много раз упоминали инициализацию, но всегда мимоходом,среди других вопросов. Теперь, после того как мы обсудили различныеклассы памяти, мы в этом разделе просуммируем некоторые правила,относящиеся к инициализации.

Если явная инициализация отсутствует, то внешним и статическимпеременным присваивается значение нуль; автоматические и регистровыепеременные имеют в этом случае неопределенные значения (мусор).

Простые переменные (не массивы или структуры) можно инициализироватьпри их описании, добавляя вслед за именем знак равенства и константноевыражение:

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).

Рекурсия.

В языке "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.

Рекурсия обычно не дает никакой экономиии памяти, поскольку приходитсягдe-то создавать стек для обрабатываемых значений. Не приводит она и ксозданию более быстрых программ. Но рекурсивные программы болеекомпактны, и они зачастую становятся более легкими для понимания инаписания. Рекурсия особенно удобна при работе с рекурсивноопределяемыми структурами данных, например, с деревьями; хорошийпример будет приведен вглаве 6.

Упражнение 4-7.
Приспособьте идеи, использованные в printd для рекурсивного написанияitoa; т.е. преобразуйте целое в строку с помощью рекурсивной процедуры.

Упражнение 4-8.
Напишите рекурсивный вариант функции reverse(s), которая располагает вобратном порядке строку s.

Препроцессор языка 'C'

В языке "C" предусмотрены определенные расширения языка с помощьюпростого макропредпроцессора. Одним из самых распространенных такихрасширений, которое мы уже использовали, является конструкция#define; другим расширением является возможность включать во времякомпиляции содержимое других файлов.

Включение файлов

Для облегчения работы с наборами конструкций #define и описаний(среди прочих средств) в языке "Си" предусмотрена возможность включенияфайлов. Любая строка вида

#include "filename"
заменяется содержимым файла с именем filename. (кавычки обязательны).Часто одна или две строки такого вида появляются в начале каждогоисходного файла, для того чтобы включить общие конструкции #define иописания extern для глобальных переменных. Допускается вложенностьконструкций #include.

Конструкция #include является предпочтительным способом связи описанийв больших программах. Этот способ гарантирует, что все исходные файлыбудут снабжены одинаковыми определениями и описаниями переменных, и,следовательно, исключает особенно неприятный сорт ошибок. Естественно,когда какой-то включаемый файл изменяется, все зависящие от него файлыдолжны быть перекомпилированы.

Макроподстановка

Определение вида

#define yes 1
приводит к макроподстановке самого простого вида - замене имени настроку символов. Имена в #define имеют ту же самую форму, что иидентификаторы в "C"; заменяющий текст совершенно произволен.Нормально заменяющим текстом является остальная часть строки;длинное определение можно продолжить, поместив \ в конец продолжаемойстроки. "область действия" имени, определенного в #define, простираетсяот точки определения до конца исходного файла. Имена могут бытьпереопределены, и определения могут использовать определения,сделанные ранее. Внутри заключенных в кавычки строк подстановки непроизводятся, так что если, например, yes - определенное имя, то вprintf("yes") не будет сделано никакой подстановки.

Так как реализация #define является частью работы макропредпроцессора,а не собственно компилятора, имеется очень мало грамматическихограничений на то, что может быть определено. Так, например, любителиалгола могут об'явить

#define then#define begin   {#define end     }
и затем написать
if (i > 0) thenbegin	a = 1;	b = 2;end

Имеется также возможность определения макроса с аргументами, так чтозаменяющий текст будет зависеть от вида обращения к макросу. Определим,например, макрос с именем мах следующим образом:

#define max(a, b) ((a) > (b) ? (a) : (b))
тогда строка
x = max(p + q, r + s);
будет заменена строкой
x = ((p + q) > (r + s) ? (p + q) : (r + s));
Такая возможность обеспечивает "функцию максимума", котораярасширяется в последовательный код, а не в обращение к функции. Приправильном обращении с аргументами такой макрос будет работать слюбыми типами данных; здесь нет необходимости в различных видах махдля данных разных типов, как это было бы с функциями.

Конечно, если вы тщательно рассмотрите приведенное выше расширениемах, вы заметите определенные недостатки. Выражения вычисляютсядважды; это плохо, если они влекут за собой побочные эффекты,вызванные, например, обращениями к функциям или использованиемопераций увеличения. Нужно позаботиться о правильном использованиикруглых скобок, чтобы гарантировать сохранение требуемого порядкавычислений. (рассмотрите макрос

#define square(x) (x)*(x)
при обращении к ней, как square(z+1)). Здесь возникают даже некоторыечисто лексические проблемы: между именем макро и левой круглой скобкой,открывающей список ее аргументов, не должно быть никаких пробелов.

Тем не менее аппарат макросов является весьма ценным. Один практическийпример дает описываемая вглаве 7 стандартная библиотека ввода-вывода,в которой getchar и putchar определены как макросы (очевидно putcharдолжна иметь аргумент), что позволяет избежать затрат на обращениек функции при обработке каждого символа.

Другие возможности макропроцессора описаны вприложении А.

Упражнение 4-9.
Определите макрос swap(x, y), который обменивает значениями два своихаргумента типа int. (в этом случае поможет блочная структура).