Аргументы - вызов по значению
Один аспект в "C" может оказаться непривычным для программистов, которые использовали другие языки, в частности, фортран и PL/1. В языке "C" все аргументы функций передаются "по значению". это означает, что вызванная функция получает значения своих аргументов с помощью временных переменных /фактически через стек/, а не их адреса. Это приводит к некоторым особенностям, отличным от тех, с которыми мы сталкивались в языках типа фортрана и PL/1, использующих "вызов по ссылке", где вызванная процедура работает с адресом аргумента, а не с его значением.
Главное отличие состоит в том, что в "C" вызванная функция не может изменить переменную из вызывающей функции; она может менять только свою собственную временную копию.
вызов по значению, однако, не помеха, а весьма ценное качество. Оно обычно приводит к более компактным программам, содержащим меньше не относящихся к делу переменных, потому что с аргументами можно обращаться как с удобно инициализированными локальными переменными вызванной процедуры. Вот, например, вариант функции power использующей это обстоятельство
power(x,n) /* raise x n-th power; n > 0; version 2 */ int x,n; { int p;
for (p = 1; n > 0; --n) p = p * x; return (p); }
аргумент n используется как временная переменная; из него вычитается единица до тех пор, пока он не станет нулем. переменная i здесь больше не нужна. чтобы ни происходило с n внутри power это никак не влияет на аргумент, с которым первоначально обратились к функции power.
При необходимости все же можно добиться, чтобы функция изменила переменную из вызывающей программы. Эта программа должна обеспечить установление адреса переменной /технически, через указатель на переменную/, а в вызываемой функции надо описать соответствующий аргумент как указатель и ссылаться к фактической переменной косвенно через него. Мы рассмотрим это подробно в лекции № 5.
Когда в качестве аргумента выступает имя массива, то фактическим значением, передаваемым функции, является адрес начала массива. /Здесь нет никакого копирования элементов массива/. С помощью индексации и адреса начала функция может найти и изменить любой элемент массива. Это - тема следующего раздела.
Функции
В языке "C" функции эквивалентны подпрограммам или функциям в фортране или процедурам в PL/1, паскале и т.д. функции дают удобный способ заключения некоторой части вычислений в черный ящик, который в дальнейшем можно использовать, не интересуясь его внутренним содержанием. Использование функций является фактически единственным способом справиться с потенциальной сложностью больших программ. Если функции организованы должным образом, то можно игнорировать то, как делается работа; достаточно знание того, что делается. Язык "C" разработан таким образом, чтобы сделать использование функций легким, удобным и эффективным. Вам будут часто встречаться функции длиной всего в несколько строчек, вызываемые только один раз, и они используются только потому, что это проясняет некоторую часть программы.
До сих пор мы использовали только предоставленные нам функции типа printf, getchar и putchar; теперь пора написать несколько наших собственных. так как в "C" нет операции возведения в степень, подобной операции ** в фортране или PL/1, давайте проиллюстрируем механику определения функции на примере функции power(m,n), возводящей целое m в целую положительную степень n. Так значение power(2,5) равно 32. Конечно, эта функция не выполняет всей работы операции **, поскольку она действует только с положительными степенями небольших чисел, но лучше не создавать дополнительных затруднений, смешивая несколько различных вопросов.
Ниже приводится функция power и использующая ее основная программа, так что вы можете видеть целиком всю структуру.
main() /* test power function */ { int i;
for(i = 0; i < 10; ++i) printf("%d %d %d\n",i,power(2,i),power(-3,i)); }
power(x,n) /* raise x n-th power; n > 0 */ int x,n; { int i, p; p = 1; for (i =1; i <= n; ++i) p = p * x; return (p); } Все функции имеют одинаковый вид: имя (список аргументов, если они имеются) описание аргументов, если они имеются { описания операторы }
Эти функции могут быть записаны в любом порядке и находиться в одном или двух исходных файлах. Конечно, если исходная программа размещается в двух файлах, вам придется дать больше указаний при компиляции и загрузке, чем если бы она находилась в одном, но это дело операционной системы, а не атрибут языка. В данный момент, для того чтобы все полученные сведения о прогоне "C" - программ, не изменились в дальнейшем, мы будем предполагать, что обе функции находятся в одном и том же файле.
функция power вызывается дважды в строке
printf("%d %d %d\n",i,power(2,i),power(-3,i));
при каждом обращении функция power, получив два аргумента, возвращает целое значение, которое печатается в заданном формате. В выражениях power(2,i) является точно таким же целым, как 2 и i. /Не все функции выдают целое значение; мы займемся этим вопросом в лекции № 4/.
Аргументы функции power должны быть описаны соответствующим образом, так как их типы известны. Это сделано в строке
int x,n;
которая следует за именем функции.
описания аргументов помещаются между списком аргументов и открывающейся левой фигурной скобкой; каждое описание заканчивается точкой с запятой. Имена, использованные для аргументов функции power, являются чисто локальными и недоступны никаким другим функциям: другие процедуры могут использовать те же самые имена без возникновения конфликта. Это верно и для переменных i и p; i в функции power никак не связано с i в функции main.
Значение, вычисленное функцией power, передаются в main с помощью оператора return, точно такого же, как в PL/1. Внутри круглых скобок можно написать любое выражение. функция не обязана возвращать какое-либо значение; оператор return, не содержащий никакого выражения, приводит к такой же передаче управления, как "сваливание на конец" функции при достижении конечной правой фигурной скобки, но при этом в вызывающую функцию не возвращается никакого полезного значения.
Упражнение 1-13
Напишите программу преобразования прописных букв из файла ввода в строчные, используя при этом функцию power(c), которая возвращает значение 'c', если 'c' - не буква, и значение соответствующей строчной буквы, если 'c' - буква.
Копирование файла
Имея в своем распоряжении только функции getchar и putchar вы можете, не зная ничего более об операциях ввода-вывода, написать удивительное количество полезных программ. Простейшим примером может служить программа посимвольного копирования вводного файла в выводной. Общая схема имеет вид:
ввести символ while (символ не является признаком конца файла) вывести только что прочитанный символ ввести новый символ
программа, написанная на языке "C", выглядит следующим образом:
main() /* copy input to output; 1st version */ { int c;
c = getchar(); while (c != EOF) { putchar (c); c = getchar(); } }
оператор отношения != означает "не равно".
Основная проблема заключается в том, чтобы зафиксировать конец файла ввода. Обычно, когда функция getchar наталкивается на конец файла ввода, она возвращает значение , не являющееся действительным символом; таким образом, программа может установить, что файл ввода исчерпан. Единственное осложнение, являющееся значительным неудобством, заключается в существовании двух общеупотребительных соглашений о том, какое значение фактически является признаком конца файла. Мы отсрочим решение этого вопроса, использовав символическое имя EOF для этого значения, каким бы оно ни было. На практике EOF будет либо -1, либо 0, так что для правильной работы перед программой должно стоять собственно либо
#define EOF -1
либо
#define EOF 0
Использовав символическую константу EOF для представления значения, возвращаемого функцией getchar при выходе на конец файла, мы обеспечили, что только одна величина в программе зависит от конкретного численного значения.
Мы также описали переменную 'c' как int, а не char, с тем чтобы она могла хранить значение, возвращаемое getchar. Как мы увидим в лекции № 2, эта величина действительно int, так как она должна быть в состоянии в дополнение ко всем возможным символам представлять и EOF.
Программистом, имеющим опыт работы на "C", программа копирования была бы написана более сжато. В языке "C" любое присваивание, такое как
c = getchar()
может быть использовано в выражении; его значение - просто значение, присваиваемое левой части. Если присваивание символа переменной 'c' поместить внутрь проверочной части оператора while, то программа копирования файла запишется в виде:
main() /* copy input to output; 2nd version */ { int c;
while ((c = getchar()) != EOF) putchar(c); }
Программа извлекает символ , присваивает его переменной 'c' и затем проверяет, не является ли этот символ признаком конца файла. Если нет - выполняется тело оператора while, выводящее этот символ. Затем цикл while повторяется. Когда, наконец, будет достигнут конец файла ввода, оператор while завершается, а вместе с ним заканчивается выполнение и функции main.
В этой версии централизуется ввод - в программе только одно обращение к функции getchar - и ужимается программа. Вложение присваивания в проверяемое условие - это одно из тех мест языка "C", которое приводит к значительному сокращению программ. Однако, на этом пути можно увлечься и начать писать недоступные для понимания программы. Эту тенденцию мы будем пытаться сдерживать.
Важно понять , что круглые скобки вокруг присваивания в условном выражении действительно необходимы. Старшинство операции != выше, чем операции присваивания =, а это означает, что в отсутствие круглых скобок проверка условия != будет выполнена до присваивания =. Таким образом, оператор
c = getchar() != EOF
эквивалентен оператору
c = (getchar() != EOF)
Это, вопреки нашему желанию, приведет к тому, что 'c' будет принимать значение 0 или 1 в зависимости от того, натолкнется или нет getchar на признак конца файла . Подробнее об этом будет сказано в лекции № 2.
Массивы
Давайте напишем программу подсчета числа появлений каждой цифры, символов пустых промежутков/пробел, табуляции, новая строка/ и всех остальных символов. Конечно, такая задача несколько искусственна, но она позволит нам проиллюстрировать в одной программе сразу несколько аспектов языка "C".
Мы разбили вводимые символы на двенадцать категорий, и нам удобнее использовать массив для хранения числа появлений каждой цифры, а не десять отдельных переменных. Вот один из вариантов программы:
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;
while ((c = getchar()) != EOF) if (c >= '0' && c <= '9') ++ndigit[c-'0']; else if(c== ' ' || c== '\n' || c== '\t') ++nwhite; else ++nother;
printf("digits ="); for (i = 0; i < 10; ++i) printf(" %d", ndigit[i]); printf("\nwhite space = %d, other = %d\n", nwhite, nother); }
описание
int ndigit[10];
объявляет, что ndigit является массивом из десяти целых. В языке "C" индексы массивавсегда начинаются с нуля /а не с 1, как в фортране или PL/1/, так что элементами массива являются ndigit[0], ndigit[1],..., ndigit[9]. эта особенность отражена в циклах for, которые инициализируют и печатают массив.
Индекс может быть любым целым выражением, которое, конечно, может включать целые переменные, такие как i, и целые константы.
Эта конкретная программа сильно опирается на свойства символьного представления цифр. Так, например, в программе проверка
if( c >= '0' && c <= '9')...
определяет, является ли символ в 'c' цифрой, и если это так, то численное значение этой цифры определяется по формуле / c - '0'/. Такой способ работает только в том случае, если значения символьных констант '0', '1' и т.д. Положительны, расположены в порядке возрастания и нет ничего, кроме цифр, между константами '0' и '9'. К счастью, это верно для всех общепринятых наборов символов.
По определению перед проведением арифметических операций, вовлекающих переменные типа char и int, все они преобразуются к типу int, так что в арифметических выражениях переменные типа char по существу идентичны переменным типа int. Это вполне естественно и удобно; например, c -'0'- это целое выражение со значением между 0 и 9 в соответствии с тем, какой символ от '0' до '9' хранится в 'c', и, следовательно, оно является подходящим индексом для массива ndigit.
Выяснение вопроса, является ли данный символ цифрой, символом пустого промежутка или чем-либо еще, осуществляется последовательностью операторов
if (c >= '0' && c <= '9') ++ndigit[c-'0']; else if(c == ' ' || c == '\n' || c == '\t') ++nwhite; else ++nother;
конструкция
if (условие) оператор else if (условие) оператор else оператор
часто встречаются в программах как средство выражения ситуаций, в которых осуществляется выбор одного из нескольких возможных решений.
Программа просто движется сверху вниз до тех пор, пока не удовлетворится какое-нибудь условие; тогда выполняется соответствующий 'оператор', и вся конструкция завершается. /Конечно, 'оператор' может состоять из нескольких операторов, заключенных в фигурные скобки/. Если ни одно из условий не удовлетворяется, то выполняется 'оператор', стоящий после заключительного else, если оно присутствует. Если последнее else и соответствующий 'оператор' опущены (как в программе подсчета слов), то никаких действий не производится. Между начальным if и конечным else может помещаться произвольное количество групп
else if (условие) оператор
С точки зрения стиля целесообразно записывать эту конструкцию так, как мы показали, с тем чтобы длинные выражения не залезали за правый край страницы.
Оператор switch (переключатель), который рассматривается в лекции № 3, представляет другую возможность для записи разветвления на несколько вариантов. этот оператор особенно удобен, когда проверяемое выражение является либо просто некоторым целым, либо символьным выражением, совпадающим с одной из некоторого набора констант. Версия этой программы, использующая оператор switch, будет для сравнения приведена в лекции № 3.
Упражнение 1-12
Напишите программу, печатающую гистограмму длин слов из файла ввода. Самое легкое - начертить гистограмму горизонтально; вертикальная ориентация требует больших усилий.
Массивы символов
По-видимому самым общим типом массива в "C" является массив символов. Чтобы проиллюстрировать использование массивов символов и обрабатывающих их функций, давайте напишем программу, которая читает набор строк и печатает самую длинную из них. Основная схема программы достаточно проста:
while (имеется еще строка) if (эта строка длиннее самой длинной из предыдущих) запомнить эту строку и ее длину напечатать самую длинную строку
По этой схеме ясно, что программа естественным образом распадается на несколько частей. Одна часть читает новую строку, другая проверяет ее, третья запоминает, а остальные части программы управляют этим процессом.
Поскольку все так прекрасно делится, было бы хорошо и написать программу соответствующим образом. Давайте сначала напишем отдельную функцию getline, которая будет извлекать следующую строку из файла ввода; это - обобщение функции getchar. Мы попытаемся сделать эту функцию по возможности более гибкой, чтобы она была полезной и в других ситуациях. Как минимум getline должна передавать сигнал о возможном появлении конца файла; более общий полезный вариант мог бы передавать длину строки или нуль, если встретится конец файла. Нуль не может быть длиной строки, так как каждая строка содержит по крайней мере один символ; даже строка, содержащая только символ новой строки, имеет длину 1.
Когда мы находим строку, которая длиннее самой длинной из предыдущих, то ее надо где-то запомнить. Это наводит на мысль о другой функции, copy, которая будет копировать новую строку в место хранения.
Наконец, нам нужна основная программа для управления функциями getline и copy. Вот результат :
#define maxline 1000 /* maximum input line size */ main() /* find longest line */ { int len; /* current line length */ int max; /* maximum length seen so far */ char line[maxline]; /* current input line */ char save[maxline]; /* longest line, saved */
max = 0; while ((len = getline(line, maxline)) > 0) if (len > max) { max = len; copy(line, save); } if (max > 0) /* there was a line */ printf("%s", save); } getline(s,lim) /* get line into s,return length */ char s[]; int lim; { int c, i;
for(i=0;i<lim-1 && (c=getchar())!=EOF && c!='\n';++i) s[i] = c; if (c == '\n') { s[i] = c; ++i; } s[i] = '\0'; return(i); }
copy(s1, s2) /* copy s1 to s2; assume s2 big enough */ char s1[], s2[]; { int i;
i = 0; while ((s2[i] = s1[i]) != '\0') ++i; }
функция main и getline общаются как через пару аргументов, так и через возвращаемое значение. аргументы getline описаны в строках
char s[]; int lim;
которые указывают, что первый аргумент является массивом, а второй - целым.
Длина массива s не указана, так как она определена в main. функция getline использует оператор return для передачи значения назад в вызывающую программу точно так же, как это делала функция power. Одни функции возвращают некоторое нужное значение; другие, подобно copy, используются из-за их действия и не возвращают никакого значения.
Чтобы пометить конец строки символов, функция getline помещает в конец создаваемого ей массива символ \0 /нулевой символ, значение которого равно нулю/. Это соглашение используется также компилятором с языка "C": когда в "C" - программе встречается строчная константа типа
"hello\n"
то компилятор создает массив символов , содержащий символы этой строки, и заканчивает его символом \0, с тем чтобы функции, подобные printf, могли зафиксировать конец массива:
----------------------------------------- ! h ! e ! l ! l ! o ! \n ! \0 ! -----------------------------------------
Спецификация формата %s указывает, что printf ожидает строку, представленную в такой форме. Проанализировав функцию copy, вы обнаружите, что и она опирается на тот факт, что ее входной аргумент оканчивается символом \0, и копирует этот символ в выходной аргумент s2. /Все это подразумевает, что символ \0 не является частью нормального текста/.
Между прочим, стоит отметить, что даже в такой маленькой программе, как эта, возникает несколько неприятных организационных проблем. Например, что должна делать main, если она встретит строку, превышающую ее максимально возможный размер? функция getline поступает разумно: при заполнении массива она прекращает дальнейшее извлечение символов, даже если не встречает символа новой строки. Проверив полученную длину и последний символ, функция main может установить, не была ли эта строка слишком длинной, и поступить затем, как она сочтет нужным. Ради краткости мы опустили эту проблему.
Пользователь функции getline никак не может заранее узнать, насколько длинной окажется вводимая строка. Поэтому в getline включен контроль переполнения. В то же время пользователь функции copy уже знает /или может узнать/, каков размер строк, так что мы предпочли не включать в эту функцию дополнительный контроль.
Упражнение 1-14
Переделайте ведущую часть программы поиска самой длинной строки таким образом, чтобы она правильно печатала длины сколь угодно длинных вводимых строк и возможно больший текст.
Упражнение 1-15
Напишите программу печати всех строк длиннее 80 символов.
Упражнение 1-16
Напишите программу, которая будет удалять из каждой строки стоящие в конце пробелы и табуляции, а также строки, целиком состоящие из пробелов.
Упражнение 1-17
Напишите функцию reverse(s), которая располагает символьную строку s в обратном порядке. С ее помощью напишите программу, которая обратит каждую строку из файла ввода.
Набор полезных программ
Теперь мы собираемся рассмотреть семейство родственных программ, предназначенных для выполнения простых операций над символьными данными. В дальнейшем вы обнаружите, что многие программы являются просто расширенными версиями тех прототипов, которые мы здесь обсуждаем.
Область действия: внешние переменные
переменные в main(line, save и т.д.) являются внутренними или локальными по отношению к функции main, потому что они описаны внутри main и никакая другая функция не имеет к ним прямого доступа. Это же верно и относительно переменных в других функциях; например, переменная i в функции getline никак не связана с i в copy. Каждая локальная переменная существует только тогда, когда произошло обращение к соответствующей функции, и исчезает, как только закончится выполнение этой функции. По этой причине такие переменные, следуя терминологии других языков, обычно называют автоматическими. Мы впредь будем использовать термин автоматические при ссылке на эти динамические локальные переменные. /в лекции № 4 обсуждается класс статической памяти, когда локальные переменные все же оказываются в состоянии сохранить свои значения между обращениями к функциям /.
Поскольку автоматические переменные появляются и исчезают вместе с обращением к функции, они не сохраняют своих значений в промежутке от одного вызова до другого, в силу чего им при каждом входе нужно явно присваивать значения. Если этого не сделать, то они будут содержать мусор.
В качестве альтернативы к автоматическим переменным можно определить переменные, которые будут внешними для всех функций, т.е. глобальными переменными, к которым может обратиться по имени любая функция, которая пожелает это сделать. (этот механизм весьма сходен с common в фортране и external в PL/1). Так как внешние переменные доступны всюду, их можно использовать вместо списка аргументов для передачи данных между функциями. Кроме того, поскольку внешние переменные существуют постоянно, а не появляются и исчезают вместе с вызываемыми функциями, они сохраняют свои значения и после того, как функции, присвоившие им эти значения, завершат свою работу.
Внешняя переменная должна быть определена вне всех функций; при этом ей выделяется фактическое место в памяти. Такая переменная должна быть также описана в каждой функции, которая собирается ее использовать; это можно сделать либо явным описанием extern, либо неявным по контексту. Чтобы сделать обсуждение более конкретным, давайте перепишем программу поиска самой длинной строки, сделав line, save и max внешними переменными. Это потребует изменения описаний и тел всех трех функций, а также обращений к ним.
#define maxline 1000 /* max. input line size*/
char line[maxline]; /* input line */ char save[maxline];/* longest line saved here*/ int max;/* length of longest line seen so far*/ main() /*find longest line; specialized version*/ { int len; extern int max; extern char save[]; max = 0;
while ( (len = getline()) > 0 ) if ( len > max ) { max = len; copy(); } if ( max > 0 ) /* there was a line */ printf( "%s", save ); }
getline() /* specialized version */ { int c, i; extern char line[];
for (i = 0; i < maxline-1
&& (c=getchar()) !=EOF && c!='\n'; ++i) line[i] = c; ++i; } line[i] = '\0' return(i) } copy() /* specialized version */ { int i; extern char line[], save[];
i = 0; while ((save[i] = line[i]) !='\0') ++i; }
Внешние переменные для функций main, getline и copy определены в первых строчках приведенного выше примера, которыми указывается их тип и вызывается отведение для них памяти. Синтаксически внешние описания точно такие же, как описания, которые мы использовали ранее, но так как они расположены вне функций, соответствующие переменные являются внешними. Чтобы функция могла использовать внешнюю переменную, ей надо сообщить ее имя. Один способ сделать - это включить в функцию описание extern; это описание отличается от предыдущих только добавлением ключевого слова extern.
В определеных ситуациях описание extern может быть опущено: если внешнее определение переменной находится в том же исходном файле, раньше ее использования в некоторой конкретной функции, то не обязательно включать описание extern для этой переменной в саму функцию. описания extern в функциях main, getline и copy являются, таким образом, излишними. Фактически, обычная практика заключается в помещении определений всех внешних переменных в начале исходного файла и последующем опускании всех описаний extern.
Если программа находится в нескольких исходных файлах, и некоторая переменная определена, скажем в файле 1, а используется в файле 2, то чтобы связать эти два вхождения переменной, необходимо в файле 2 использовать описание extern. Этот вопрос подробно обсуждается в лекции № 4.
Вы должно быть заметили, что мы в этом разделе при ссылке на внешние переменные очень аккуратно используем слова описание и определение. "определение" относится к тому месту, где переменная фактически заводится и ей выделяется память; "описание" относится к тем местам, где указывается природа переменной, но никакой памяти не отводится.
Между прочим, существует тенденция объявлять все, что ни попадется, внешними переменными, поскольку кажется, что это упрощает связи, - списки аргументов становятся короче и переменные всегда присутствуют, когда бы вам они ни понадобились. Но внешние переменные присутствуют и тогда, когда вы в них не нуждаетесь. Такой стиль программирования чреват опасностью, так как он приводит к программам, связи данных внутри которых не вполне очевидны. переменные при этом могут изменяться неожиданным и даже неумышленным образом, а программы становится трудно модифицировать, когда возникает такая необходимость. Вторая версия программы поиска самой длинной строки уступает первой отчасти по этим причинам, а отчасти потому, что она лишила универсальности две весьма полезные функции, введя в них имена переменных, с которыми они будут манипулировать.
Упражнение 1-18
Проверка в операторе for функции getline довольно неуклюжа. Перепишите программу таким образом, чтобы сделать эту проверку более ясной, но сохраните при этом то же самое поведение в конце файла и при переполнении буфера. Является ли это поведение самым разумным?
Оператор FOR
Как и можно было ожидать, имеется множество различных способов написания каждой программы. Давайте рассмотрим такой вариант программы перевода температур:
main() /* fahrenheit-celsius table */ { int fahr; for (fahr = 0; fahr <= 300; fahr = fahr + 20) printf("%4d %6.1f\n", fahr, (5.0/9.0)*(fahr-32.0)); }
Эта программа выдает те же самые результаты, но выглядит безусловно по-другому. Главное изменение - исключение большинства переменных; осталась только переменная fahr, причем типа int (это сделано для того, чтобы продемонстрировать преобразование %d в функции printf). Нижняя и верхняя границы и размер шага появляются только как константы в операторе for, который сам является новой конструкцией, а выражение, вычисляющее температуру по цельсию, входит теперь в виде третьего аргумента функции printf, а не в виде отдельного оператора присваивания.
Последнее изменение является примером вполне общего правила языка "C" - в любом контексте, в котором допускается использование значения переменной некоторого типа, вы можете использовать выражение этого типа. Так как третий аргумент функции printf должен иметь значение с плавающей точкой, чтобы соответствовать спецификации %6.1f, то в этом месте может встретиться любое выражение плавающего типа.
Сам оператор for - это оператор цикла, обобщающий оператор while. Его функционирование должно стать ясным, если вы сравните его с ранее описанным оператором while. оператор for содержит три части, разделяемые точкой с запятой. Первая часть
fahr = 0
выполняется один раз перед входом в сам цикл. Вторая часть - проверка, или условие, которое управляет циклом:
fahr <= 300
это условие проверяется и, если оно истинно, то выполняется тело цикла (в данном случае только функция printf ). Затем выполняется шаг реинициализации
fahr =fahr + 20
и условие проверяется снова. цикл завершается, когда это условие становится ложным. Так же, как и в случае оператора while, тело цикла может состоять из одного оператора или из группы операторов, заключенных в фигурные скобки. Инициализирующая и реинициализирующая части могут быть любыми отдельными выражениями.
Выбор между операторами while и for произволен и основывается на том , что выглядит яснее. Оператор for обычно удобен для циклов, в которых инициализация и реинициализация логически связаны и каждая задается одним оператором, так как в этом случае запись более компактна, чем при использовании оператора while, а операторы управления циклом сосредотачиваются вместе в одном месте.
Упражнение 1-5
Модифицируйте программу перевода температур таким образом, чтобы она печатала таблицу в обратном порядке, т.е. От 300 градусов до 0.
Переменные и арифметика
Следующая программа печатает приведенную ниже таблицу температур по Фаренгейту и их эквивалентов по стоградусной шкале Цельсия, используя для перевода формулу
c = (5/9)*(f-32). 0 -17.8 20 -6.7 40 4.4 60 15.6 ... ... 260 126.7 280 137.8 300 140.9
Теперь сама программа:
/* print fahrenheit-celsius table for f = 0, 20, ..., 300 */ main() { int lower, upper, step; float fahr, celsius; lower = 0; /* lower limit of temperature table */ upper =300; /* upper limit */ step = 20; /* step size */ fahr = lower; while (fahr <= upper) { celsius = (5.0/9.0) * (fahr -32.0); printf("%4.0f %6.1f\n", fahr, celsius); fahr = fahr + step; } }
Первые две строки
/* print fahrenheit-celsius table for f = 0, 20, ..., 300 */
являются комментарием, который в данном случае кратко поясняет, что делает программа. Любые символы между /* и */ игнорируются компилятором; можно свободно пользоваться комментариями для облегчения понимания программы. Комментарии могут появляться в любом месте, где возможен пробел или переход на новую строку.
В языке "C" все переменные должны быть описаны до их использования, обычно это делается в начале функции до первого выполняемого оператора. Если вы забудете вставить описание, то получите диагностическое сообщение от компилятора. описание состоит из типа и списка переменных, имеющих этот тип, как в
int lower, upper, step; float fahr, celsius;
тип int означает, что все переменные списка целые; тип float предназначен для чисел с плавающей точкой, т.е. для чисел, которые могут иметь дробную часть. Точность как int, так и float зависит от конкретной машины, на которой вы работаете. На PDP-11, например, тип int соответствует 16-битовому числу со знаком, т.е. числу, лежащему между -32768 и +32767. Число типа float - это 32-битовое число, имеющее около семи значащих цифр и лежащее в диапазоне от 10е-38 до 10е+38. В лекции № 2 приводится список размеров для других машин.
В языке "C" предусмотрено несколько других основных типов данных, кроме int и float:
| char | символ - один байт |
| short | короткое целое |
| long | длинное целое |
| double | плавающее с двойной точностью |
Размеры этих объектов тоже машинно-независимы; детали приведены в лекции № 2. Имеются также массивы, структуры и объединения этих основных типов, указатели на них и функции,которые их возвращают; со всеми ними мы встретимся в свое время.
Фактически вычисления в программе перевода температур начинаются с операторов присваивания
lower = 0; upper =300; step = 20; fahr =lower;
которые придают переменным их начальные значения. каждый отдельный оператор заканчивается точкой с запятой.
Каждая строка таблицы вычисляется одинаковым образом, так что мы используем цикл, повторяющийся один раз на строку. В этом назначение оператора while:
while (fahr <= upper) { .... }
проверяется условие в круглых скобках. Если оно истинно (fahr меньше или равно upper ), то выполняется тело цикла (все операторы, заключенные в фигурные скобки { и }). Затем вновь проверяется это условие и, если оно истинно, опять выполняется тело цикла. Если же условие не выполняется (fahr превосходит upper), цикл заканчивается и происходит переход к выполнению оператора, следующего за оператором цикла. Так как в настоящей программе нет никаких последующих операторов, то выполнение программы завершается.
Тело оператора while может состоять из одного или более операторов, заключенных в фигурные скобки, как в программе перевода температур, или из одного оператора без скобок, как, например, в
while (i<j) i = 2 * i;
В обоих случаях операторы, управляемые оператором while, сдвинуты на одну табуляцию, чтобы вы могли с первого взгляда видеть, какие операторы находятся внутри цикла. Такой сдвиг подчеркивает логическую структуру программы. Хотя в языке "C" допускается совершенно произвольное расположение операторов в строке, подходящий сдвиг и использование пробелов значительно облегчают чтение программ. Мы рекомендуем писать только один оператор на строке и (обычно) оставлять пробелы вокруг операторов. Расположение фигурных скобок менее существенно; мы выбрали один из нескольких популярных стилей. Выберите подходящий для вас стиль и затем используйте его последовательно.
Основная часть работы выполняется в теле цикла. Температура по Цельсию вычисляется и присваивается переменной celsius оператором
celsius = (5.0/9.0) * (fahr-32.0);
причина использования выражения 5.0/9.0 вместо выглядящего проще 5/9 заключается в том, что в языке "C", как и во многих других языках, при делении целых происходит усечение, состоящее в отбрасывании дробной части результата. Таким образом, результат операции 5/9 равен нулю, и, конечно, в этом случае все температуры оказались бы равными нулю. Десятичная точка в константе указывает, что она имеет тип с плавающей точкой, так что, как мы и хотели, 5.0/9.0 равно 0.5555....
Мы также писали 32.0 вместо 32, несмотря на то, что так как переменная fahr имеет тип float, целое 32 автоматически бы преобразовалось к типу float (в 32.0) перед вычитанием. С точки зрения стиля разумно писать плавающие константы с явной десятичной точкой даже тогда, когда они имеют целые значения; это подчеркивает их плавающую природу для просматривающего программу и обеспечивает то, что компилятор будет смотреть на вещи так же, как и Вы.
Подробные правила о том, в каком случае целые преобразуются к типу с плавающей точкой, приведены в лекции № 2. Сейчас же отметим, что присваивание
fahr = lower;
проверка
while (fahr <= upper)
работают, как ожидается, - перед выполнением операций целые преобразуются в плавающую форму.
Этот же пример сообщает чуть больше о том, как работает printf. функция printf фактически является универсальной функцией форматных преобразований, которая будет полностью описана в лекции № 7. Ее первым аргументом является строка символов, которая должна быть напечатана, причем каждый знак % указывает, куда должен подставляться каждый из остальных аргументов /второй, третий, .../ и в какой форме он должен печататься. Например, в операторе
printf("%4.0f %6.1f\n", fahr, celsius);
Спецификация преобразования %4.0f говорит, что число с плавающей точкой должно быть напечатано в поле шириной по крайней мере в четыре символа без цифр после десятичной точки. спецификация %6.1f описывает другое число, которое должно занимать по крайней мере шесть позиций с одной цифрой после десятичной точки, аналогично спецификациям f6.1 в фортране или f(6,1) в PL/1. Различные части спецификации могут быть опущены: спецификация %6f говорит, что число будет шириной по крайней мере в шесть символов; спецификация %2 требует двух позиций после десятичной точки, но ширина при этом не ограничивается; спецификация %f говорит только о том, что нужно напечатать число с плавающей точкой. функция printf также распознает следующие спецификации:
%d - для десятичного целого,%о - для восьмеричного числа, %х - для шестнадцатеричного, %с - для символа, %s - для символьной строки %% - для самого символа %.
Подсчет символов
Следующая программа подсчитывает число символов; она представляет собой небольшое развитие программы копирования.
main() /* count characters in input */ { long nc;
nc = 0; while (getchar() != EOF) ++nc; printf("%1d\n", nc); }
оператор
++nc;
демонстрирует новую операцию, ++, которая означает увеличение на единицу. Вы могли бы написать nc = nc + 1, но ++nc более кратко и зачастую более эффективно. Имеется соответствующая операция -- уменьшение на единицу. Операции ++ и -- могут быть либо префиксными (++nc), либо постфиксными (nc++); эти две формы, как будет показано в лекции № 2, имеют в выражениях различные значения, но как ++nc, так и nc++ увеличивают nc. Пока мы будем придерживаться префиксных операций.
Программа подсчета символов накапливает их количество в переменной типа long, а не int. На PDP-11 максимальное значение равно 32767, и если описать счетчик как int, то он будет переполняться даже при сравнительно малом файле ввода; на языке "C" для HONEYWELL и IBM типы long и int являются синонимами и имеют значительно больший размер. Спецификация преобразования %1d указывает printf, что соответствующий аргумент является целым типа long.
Чтобы справиться с еще большими числами, вы можете использовать тип double / float двойной длины/. Мы также используем оператор for вместо while с тем, чтобы проиллюстрировать другой способ записи цикла.
main() /* count characters in input */ { double nc;
for (nc = 0; getchar() != EOF; ++nc) ; printf("%.0f\n", nc); }
функция printf использует спецификацию %f как для float, так и для double; спецификация %.0f подавляет печать несуществующей дробной части.
Тело оператора цикла for здесь пусто, так как вся работа выполняется в проверочной и реинициализационной частях. Но грамматические правила языка "C" требуют, чтобы оператор for имел тело. Изолированная точка с запятой, соответствующая пустому оператору, появляется здесь, чтобы удовлетворить этому требованию. Мы выделили ее на отдельную строку, чтобы сделать ее более заметной.
Прежде чем мы распростимся с программой подсчета символов, отметим, что если файл ввода не содержит никаких символов, то условие в while или for не выполнится при самом первом обращении к getchar, и, следовательно, программа выдаст нуль, т.е. Правильный ответ. это важное замечание. одним из приятных свойств операторов while и for является то, что они проверяют условие в начале цикла, т.е. До выполнения тела. Если делать ничего не надо, то ничего не будет сделано, даже если это означает, что тело цикла никогда не будет выполняться. программы должны действовать разумно, когда они обращаются с файлами типа "никаких символов". операторы while и for помогают обеспечить правильное поведение программ при граничных значениях проверяемых условий.
Подсчет слов
Четвертая программа из нашей серии полезных программ подсчитывает количество строк, слов и символов, используя при этом весьма широкое определение, что словом является любая последовательность символов, не содержащая пробелов, табуляций или новых строк. /Это - упрощенная версия утилиты 'WC' системы 'UNIX'/
#define yes 1 #define no 0
main() /* count lines, words, chars in input */ { int c, nc, nl, nw, inword;
inword = no; nl = nw = nc = 0; while((c = getchar()) != EOF) { ++nc; if (c == '\n') ++nl; if (c==' ' || c=='\n' || c=='\t') inword = no; else if (inword == no) { inword = yes; ++nw; } } printf("%d %d %d\n", nl, nw, nc); }
Каждый раз, когда программа встречает первый символ слова, она увеличивает счетчик числа слов на единицу. переменная inword следит за тем, находится ли программа в настоящий момент внутри слова или нет; сначала этой переменной присваивается " не в слове", чему соответствует значение no. Мы предпочитаем символические константы yes и no литерным значениям 1 и 0, потому что они делают программу более удобной для чтения. Конечно, в такой крошечной программе, как эта, это не приводит к заметной разнице, но в больших программах увеличение ясности вполне стоит тех скромных дополнительных усилий, которых требует следование этому принципу с самого начала. Вы также обнаружите, что существенные изменения гораздо легче вносить в те программы, где числа фигурируют только в качестве символьных констант.
Строка
nl = nw = nc = 0;
полагает все три переменные равными нулю. Это не особый случай, а следствие того обстоятельства, что оператору присваивания соответствует некоторое значение и присваивания проводятся последовательно справа налево. Таким образом, дело обстоит так, как если бы мы написали
nc = (nl = (nw = 0));
операция || Означает or, так что строка
if( c==' ' || c=='\n' || c=='\t')
говорит "если с - пробел, или с - символ новой строки, или с -табуляция ..."./условная последовательность \t является изображением символа табуляции/.
Имеется соответствующая операция && для and. Выражения, связанные операциями && или ||, рассматриваются слева на право, и при этом гарантируется, что оценивание выражений будет прекращено, как только станет ясно, является ли все выражение истинным или ложным. Так, если 'c' оказывается пробелом, то нет никакой необходимости проверять, является ли 'c' символом новой строки или табуляции, и такие проверки действительно не делаются. В данном случае это не имеет принципиального значения, но, как мы скоро увидим, в более сложных ситуациях эта особенность языка весьма существенна.
Этот пример также демонстрирует оператор else языка "C", который указывает то действие, которое должно выполняться, если условие, содержащееся в операторе if, окажется ложным.
Общая форма такова:
Подсчет строк
Следующая программа подсчитывает количество строк в файле ввода. Предполагается, что строки ввода заканчиваются символом новой строки \n, скрупулезно добавленным к каждой выписанной строке.
main() /* count lines in input */ { int c,nl;
nl = 0; while ((c = getchar()) != EOF) if (c =='\n') ++nl; printf("%d\n", nl); }
Тело while теперь содержит оператор if, который в свою очередь управляет оператором увеличения ++nl. Оператор if проверяет заключенное в круглые скобки условие и, если оно истинно, выполняет следующий за ним оператор /или группу операторов, заключенных в фигурные скобки/. Мы опять использовали сдвиг вправо, чтобы показать, что чем управляет.
Удвоенный знак равенства == является обозначением в языке "C" для "равно" /аналогично .eq. В фортране/. Этот символ введен для того, чтобы отличать проверку на равенство от одиночного =, используемого при присваивании. Поскольку в типичных "C" - программах знак присваивания встречается примерно в два раза чаще, чем проверка на равенство, то естественно, чтобы знак оператора был вполовину короче.
Любой отдельный символ может быть записан внутри одиночных кавычек, и при этом ему соответствует значение, равное численному значению этого символа в машинном наборе символов; это называется символьной константой. Так, например, 'a' - символьная константа; ее значение в наборе символов ASCII /американский стандартный код для обмена информацией/ равно 65, внутреннему представлению символа а. Конечно, 'a' предпочтительнее, чем 65: его смысл очевиден и он не зависит от конкретного машинного набора символов.
Условные последовательности, используемые в символьных строках, также занимают законное место среди символьных констант. Так в проверках и арифметических выражениях '\n' представляет значение символа новой строки. Вы должны твердо уяснить, что '\n' - отдельный символ, который в выражениях эквивалентен одиночному целому; с другой стороны "\n" - это символьная строка, которая содержит только один символ. Вопрос о сопоставлении строк и символов обсуждается в лекции № 2.
Упражнение 1-6
Напишите программу для подсчета пробелов, табуляций и новых строк.
Упражнение 1-7
Напишите программу, которая копирует ввод на вывод, заменяя при этом каждую последовательность из одного или более пробелов на один пробел.
Резюме
На данном этапе мы обсудили то, что можно бы назвать традиционным ядром языка "C". Имея эту горсть строительных блоков, можно писать полезные программы весьма значительного размера, и было бы вероятно неплохой идеей, если бы вы задержались здесь на какое-то время и поступили таким образом: следующие ниже упражнения предлагают вам ряд программ несколько большей сложности, чем те, которые были приведены в этой лекции.
После того как вы овладеете этой частью "C", приступайте к чтению следующих нескольких лекций. Усилия, которые вы при этом затратите, полностью окупятся, потому что в этих лекциях обсуждаются именно те стороны "C", где мощь и выразительность языка начинает становиться очевидной.
Упражнение 1-19
Напишите программу detab, которая заменяет табуляции во вводе на нужное число пробелов так, чтобы промежуток достигал следующей табуляционной остановки. Предположите фиксированный набор табуляционных остановок, например, через каждые n позиций.
Упражнение 1-20
Напишите программу entab, которая заменяет строки пробелов минимальным числом табуляций и пробелов, достигая при этом тех же самых промежутков. Используйте те же табуляционные остановки, как и в detab.
Упражнение 1-21
Напишите программу для "сгибания" длинных вводимых строк после последнего отличного от пробела символа, стоящего до столбца n ввода, где n - параметр. убедитесь, что ваша программа делает что-то разумное с очень длинными строками и в случае, когда перед указанным столбцом нет ни табуляций, ни пробелов.
Упражнение 1-22
Напишите программу удаления из "C"-программы всех комментариев. Не забывайте аккуратно обращаться с "закавыченными" строками и символьными константами.
Упражнение 1-23
Напишите программу проверки "C"-программы на элементарные синтаксические ошибки, такие как несоответствие круглых, квадратных и фигурных скобок. Не забудьте о кавычках, как одиночных, так и двойных, и о комментариях. (Эта программа весьма сложна, если вы будете писать ее для самого общего случая).
Учебное введение
Давайте начнем с быстрого введения в язык "C". Наша цель - продемонстрировать существенные элементы языка на реальных программах, не увязая при этом в деталях, формальных правилах и исключениях. В этой лекции мы не пытаемся изложить язык полностью или хотя бы строго (разумеется, приводимые примеры будут корректными). Мы хотим как можно скорее довести вас до такого уровня, на котором вы были бы в состоянии писать полезные программы, и чтобы добиться этого, мы сосредотачиваемся на основном: переменных и константах, арифметике, операторах передачи управления, функциях и элементарных сведениях о вводе и выводе. Мы совершенно намеренно оставляем за пределами этой лекции многие элементы языка "C", которые имеют первостепенное значение при написании больших программ, в том числе указатели, структуры, большую часть из богатого набора операторов языка "C", несколько операторов передачи управления и несметное количество деталей.
Такой подход имеет, конечно, свои недостатки. Самым существенным является то, что полное описание любого конкретного элемента языка не излагается в одном месте, а пояснения, в силу краткости, могут привести к неправильному истолкованию. Кроме того, из-за невозможности использовать всю мощь языка, примеры оказываются не столь краткими и элегантными, как они могли бы быть. И хотя мы старались свести эти недостатки к минимуму, все же имейте их ввиду.
Другой недостаток состоит в том, что последующие лекции будут неизбежно повторять некоторые части этой лекции. Мы надеемся, что такое повторение будет скорее помогать, чем раздражать.
Во всяком случае, опытные программисты должны оказаться в состоянии проэкстраполировать материал данной лекции на свои собственные программистские нужды. Начинающие же должны в дополнение писать аналогичные маленькие самостоятельные программы. И те, и другие могут использовать эту лекцию как каркас, на который будут навешиваться более подробные описания, начинающиеся с лекции № 2.
Ввод и вывод символов
Стандартная библиотека включает функции для чтения и записи по одному символу за один раз. функция getchar() извлекает следующий вводимый символ каждый раз, как к ней обращаются, и возвращает этот символ в качестве своего значения. Это значит, что после
c = getchar()
переменная 'c' содержит следующий символ из входных данных. Символы обычно поступают с терминала, но это не должно нас касаться до лекции № 7.
функция putchar(c) является дополнением к getchar: в результате обращения
putchar (c)
содержимое переменной 'c' выдается на некоторый выходной носитель, обычно опять на терминал. Обращение к функциям putchar и printf могут перемежаться; выдача будет появляться в том порядке, в котором происходят обращения.
Как и функция printf, функции getchar и putchar не содержат ничего экстраординарного. Они не входят в состав языка "C", но к ним всегда можно обратиться.
Функции и структура программ
Другой пример преобразования char в int дает функция lower, преобразующая данную прописную букву в строчную. Если выступающий в качестве аргумента символ не является прописной буквой, то lower возвращает его неизменным. Приводимая ниже программа справедлива только для набора символов ASCII.
lower(c) /* convert c to lower case; ascii only */ int c; { if ( c >= 'a' && c <= 'z' ) return( c + '@' - 'a'); else /*@ Записано вместо 'a' строчного*/ return(c); }
Эта функция правильно работает при коде ASCII, потому что численные значения, соответствующие в этом коде прописным и строчным буквам, отличаются на постоянную величину, а каждый алфавит является сплошным - между а и z нет ничего, кроме букв. Это последнее замечание для набора символов ebcdic систем IBM 360/370 оказывается несправедливым, в силу чего эта программа на таких системах работает неправильно - она преобразует не только буквы.
При преобразовании символьных переменных в целые возникает один тонкий момент. Дело в том, что сам язык не указывает, должны ли переменным типа char соответствовать численные значения со знаком или без знака. Может ли при преобразовании char в int получиться отрицательное целое? К сожалению, ответ на этот вопрос меняется от машины к машине, отражая расхождения в их архитектуре. На некоторых машинах (PDP-11, например) переменная типа char, крайний левый бит которой содержит 1, преобразуется в отрицательное целое ("знаковое расширение"). На других машинах такое преобразование сопровождается добавлением нулей с левого края, в результате чего всегда получается положительное число.
определение языка "C" гарантирует, что любой символ из стандартного набора символов машины никогда не даст отрицательного числа, так что эти символы можно свободно использовать в выражениях как положительные величины. Но произвольные комбинации двоичных знаков, хранящиеся как символьные переменные на некоторых машинах, могут дать отрицательные значения, а на других положительные.
Наиболее типичным примером возникновения такой ситуации является случай, когда значение -1 используется в качестве EOF. Рассмотрим программу
Преобразования возникают и при присваиваниях; значение правой части преобразуется к типу левой, который и является типом результата. Символьные переменные преобразуются в целые либо со знаковым расширением ,либо без него, как описано выше. Обратное преобразование int в char ведет себя хорошо - лишние биты высокого порядка просто отбрасываются. Таким образом
int i; char c; i = c; c = i;
значение 'с' не изменяется. Это верно независимо от того, вовлекается ли знаковое расширение или нет.
Если х типа float, а i типа int, то как
х = i; так и i = х;
приводят к преобразованиям; при этом float преобразуется в int отбрасыванием дробной части. тип double преобразуется во float округлением. Длинные целые преобразуются в более короткие целые и в переменные типа char посредством отбрасывания лишних битов высокого порядка.
Так как аргумент функции является выражением, то при передаче функциям аргументов также происходит преобразование типов: в частности, char и short становятся int, а float становится double. Именно поэтому мы описывали аргументы функций как int и double даже тогда, когда обращались к ним с переменными типа CHAR и float.
Наконец, в любом выражении может быть осуществлено ("принуждено") явное преобразование типа с помощью конструкции, называемой перевод (cast). В этой конструкции, имеющей вид
(имя типа) выражение
Выражение преобразуется к указанному типу по правилам преобразования, изложенным выше. Фактически точный смысл операции перевода можно описать следующим образом: выражение как бы присваивается некоторой переменной указанного типа, которая затем используется вместо всей конструкции. Например, библиотечная процедура sqrt ожидает аргумента типа double и выдаст бессмысленный ответ, если к ней по небрежности обратятся с чем-нибудь иным. таким образом, если n - целое, то выражение
sqrt((double) n)
до передачи аргумента функции sqrt преобразует n к типу double. (Отметим, что операция перевод преобразует значение n в надлежащий тип; фактическое содержание переменной n при этом не изменяется). Операция перевода имеет тот же уровень старшинства, что и другие унарные операции, как указывается в таблице в конце этой лекции.
Упражнение 2-2
Составьте программу для функции htoi(s), которая преобразует строку шестнадцатеричных цифр в эквивалентное ей целое значение. При этом допустимыми цифрами являются цифры от 1 до 9 и буквы от а до F.
Имена переменных
Хотя мы этого сразу прямо не сказали, существуют некоторые ограничения на имена переменных и символических констант. Имена составляются из букв и цифр; первый символ должен быть буквой. Подчеркивание "_" тоже считается буквой; это полезно для удобочитаемости длинных имен переменных. Прописные и строчные буквы различаются; традиционная практика в "с" - использовать строчные буквы для имен переменных, а прописные - для символических констант.
Играют роль только первые восемь символов внутреннего имени, хотя использовать можно и больше. Для внешних имен, таких как имена функций и внешних переменных, это число может оказаться меньше восьми, так как внешние имена используются различными ассемблерами и загрузчиками. Детали приводятся в приложении А. Кроме того, такие ключевые слова как if, else, int, float и т.д., зарезервированы: вы не можете использовать их в качестве имен переменных. (Они пишутся строчными буквами).
Конечно, разумно выбирать имена переменных таким образом, чтобы они означали нечто, относящееся к назначению переменных, и чтобы было менее вероятно спутать их при написании.
Константное выражение
Константное выражение - это выражение, состоящее из одних констант. Такие выражения обрабатываются во время компиляции, а не при прогоне программы, и соответственно могут быть использованы в любом месте, где можно использовать константу, как, например в
#define maxline 1000 char line[maxline+1];
или
seconds = 60 * 60 * hours;
Константы
Константы типа int и float мы уже рассмотрели. Отметим еще только, что как обычная
123.456е-7,
так и "научная" запись
0.12е3
для float является законной.
Каждая константа с плавающей точкой считается имеющей тип double, так что обозначение "e" служит как для float, так и для double.
Длинные константы записываются в виде 123l. Обычная целая константа, которая слишком длинна для типа int, рассматривается как long.
Существует система обозначений для восьмеричных и шестнадцатеричных констант: лидирующий 0(нуль) в константе типа int указывает на восьмеричную константу, а стоящие впереди 0x соответствуют шестнадцатеричной константе. Например, десятичное число 31 можно записать как 037 в восьмеричной форме и как 0x1f в шестнадцатеричной. Шестнадцатеричные и восьмеричные константы могут также заканчиваться буквой l, что делает их относящимися к типу long.
Операции и выражения присваивания
Такие выражения, как
i = i + 2
в которых левая часть повторяется в правой части могут быть записаны в сжатой форме
i += 2
используя операцию присваивания вида +=.
Большинству бинарных операций (операций подобных +, которые имеют левый и правый операнд) соответствует операция присваивания вида оп=, где оп - одна из операций
+ - * / % << >> & \^ \!
Если е1 и е2 - выражения, то е1 оп= е2 эквивалентно
е1 = (е1) оп (е2)
за исключением того, что выражение е1 вычисляется только один раз. Обратите внимание на круглые скобки вокруг е2:
x *= y + 1
то
x = x * (y + 1)
не
x = x * y + 1
В качестве примера приведем функцию bitcount, которая подсчитывает число равных 1 битов у целого аргумента.
bitcount(n) /* count 1 bits in n */ unsigned n; ( int b; for (b = 0; n != 0; n >>= 1) if (n & 01) b++; return(b); )
Не говоря уже о краткости, такие операторы присваивания имеют то преимущество, что они лучше соответствуют образу человеческого мышления. Мы говорим: "прибавить 2 к i" или "увеличить i на 2", но не "взять i, прибавить 2 и поместить результат опять в i". Итак, i += 2. Кроме того, в громоздких выражениях, подобных
yyval[yypv[p3+p4] + yypv[p1+p2]] += 2
Tакая операция присваивания облегчает понимание программы, так как читатель не должен скрупулезно проверять, являются ли два длинных выражения действительно одинаковыми, или задумываться, почему они не совпадают. Такая операция присваивания может даже помочь компилятору получить более эффективную программу.
Мы уже использовали тот факт, что операция присваивания имеет некоторое значение и может входить в выражения; самый типичный пример
while ((c = getchar()) != EOF)
присваивания, использующие другие операции присваивания (+=, -= и т.д.) также могут входить в выражения, хотя это случается реже.
типом выражения присваивания является тип его левого операнда.
Упражнение 2-9
В двоичной системе счисления операция x&(x-1) обнуляет самый правый равный 1 бит переменной x.(почему?) используйте это замечание для написания более быстрой версии функции bitcount.
Операции отношения и логические операции
Операциями отношения являются
=> > =< <
все они имеют одинаковое старшинство. Непосредственно за ними по уровню старшинства следуют операции равенства и неравенства:
== !=
которые тоже имеют одинаковое старшинство. операции отношения младше арифметических операций, так что выражения типа i<lim-1 понимаются как i<(lim-1), как и предполагается.
Логические связки && и || более интересны. Выражения, связанные операциями && и ||, вычисляются слева направо, причем их рассмотрение прекращается сразу же как только становится ясно, будет ли результат истиной или ложью. учет этих свойств очень существенен для написания правильно работающих программ. Рассмотрим, например, оператор цикла в считывающей строку функции getline, которую мы написали в лекции №1.
for(i=0;i<lim-1 && (c=getchar()) != '\n' && c != EOF; ++i) s[i]=c;
Ясно, что перед считыванием нового символа необходимо проверить, имеется ли еще место в массиве s, так что условие i<lim-1 должно проверяться первым. И если это условие не выполняется, мы не должны считывать следующий символ.
Так же неудачным было бы сравнение 'c' с EOF до обращения к функции getchar: прежде чем проверять символ, его нужно считать.
Старшинство операции && выше, чем у ||, и обе они младше операций отношения и равенства. Поэтому такие выражения, как
i<lim-1 && (c = getchar()) != '\n' && c != EOF
не нуждаются в дополнительных круглых скобках. Но так как операция != старше операции присваивания, то для достижения правильного результата в выражении
(c = getchar()) != '\n'
скобки необходимы.
Унарная операция отрицания ! Преобразует ненулевой или истинный операнд в 0, а нулевой или ложный операнд в 1. Обычное использование операции ! Заключается в записи
if( ! inword )
Вместо
if( inword == 0 )
Tрудно сказать, какая форма лучше. конструкции типа ! inword Читаются довольно удобно ("если не в слове"). Но в более сложных случаях они могут оказаться трудными для понимания.
Упражнение 2-1
Напишите оператор цикла, эквивалентный приведенному выше оператору for, не используя операции &&.
Операции увеличения и уменьшения
В языке "C" предусмотрены две необычные операции для увеличения и уменьшения значений переменных. Операция увеличения ++ добавляет 1 к своему операнду, а операция уменьшения -- вычитает 1. Мы часто использовали операцию ++ для увеличения переменных, как, например, в
if(c == '\n') ++i;
Необычный аспект заключается в том, что ++ и -- можно использовать либо как префиксные операции (перед переменной, как в ++n), либо как постфиксные (после переменной: n++). Эффект в обоих случаях состоит в увеличении n. Но выражение ++n увеличивает переменную n до использования ее значения, в то время как n++ увеличивает переменную n после того, как ее значение было использовано. Это означает, что в контексте, где используется значение переменной, а не только эффект увеличения, использование ++n и n++ приводит к разным результатам. Если n = 5, то
х = n++;
устанавливает х равным 5, а
х = ++n;
полагает х равным 6. В обоих случаях n становится равным 6. Операции увеличения и уменьшения можно применять только к переменным; выражения типа х=(i+j)++ являются незаконными.
В случаях, где нужен только эффект увеличения, а само значение не используется, как, например, в
if ( c == '\n' ) nl++;
выбор префиксной или постфиксной операции является делом вкуса. но встречаются ситуации, где нужно использовать именно ту или другую операцию. Рассмотрим, например, функцию squeeze(s,c), которая удаляет символ 'с' из строки s, каждый раз, как он встречается.
squeeze(s,c) /* delete all c from s */ char s[]; int c; { int i, j;
for ( i = j = 0; s[i] != '\0'; i++) if ( s[i] != c ) s[j++] = s[i]; s[j] = '\0'; }
Каждый раз, как встречается символ, отличный от 'с', он копируется в текущую позицию j, и только после этого j увеличивается на 1, чтобы быть готовым для поступления следующего символа. Это в точности эквивалентно записи
if ( s[i] != c ) { s[j] = s[i]; j++; }
Другой пример подобной конструкции дает функция getline, которую мы запрограммировали в лекции №1, где можно заменить
if ( c == '\n' ) { s[i] = c; ++i; }
более компактной записью
if ( c == '\n' ) s[i++] = c;
В качестве третьего примера рассмотрим функцию strcat(s,t), которая приписывает строку t в конец строки s, образуя конкатенацию строк s и t. При этом предполагается, что в s достаточно места для хранения полученной комбинации.
strcat(s,t) /* concatenate t to end of s */ char s[], t[]; /* s must be big enough */ { int i, j;
i = j = 0; while (s[i] != '\0') / *find end of s */ i++; while((s[i++] = t[j++]) != '\0') /*copy t*/ ; }
Tак как из t в s копируется каждый символ, то для подготовки к следующему прохождению цикла постфиксная операция ++ применяется к обеим переменным i и j.
Упражнение 2-3
Напишите другой вариант функции squeeze(s1,s2), который удаляет из строки s1 каждый символ, совпадающий с каким-либо символом строки s2.
Упражнение 2-4
Напишите программу для функции any(s1,s2), которая находит место первого появления в строке s1 какого-либо символа из строки s2 и, если строка s1 не содержит символов строки s2, возвращает значение -1.
Описания
Все переменные должны быть описаны до их использования, хотя некоторые описания делаются неявно, по контексту. описание состоит из спецификатора типа и следующего за ним списка переменных, имеющих этот тип, как, например,
int lower, upper, step; char c, line[1000];
переменные можно распределять по описаниям любым образом; приведенные выше списки можно с тем же успехом записать в виде
int lower; int upper; int step; char c; char line[1000];
Такая форма занимает больше места, но она удобна для добавления комментария к каждому описанию и для последующих модификаций.
переменным могут быть присвоены начальные значения внутри их описания, хотя здесь имеются некоторые ограничения. Если за именем переменной следуют знак равенства и константа, то эта константа служит в качестве инициализатора, как, например, в
char backslash = '\\'; int i = 0; float eps = 1.0e-5;
Если рассматриваемая переменная является внешней или статической, то инициализация проводится только один раз, согласно концепции до начала выполнения программы. Инициализируемым явно автоматическим переменным начальные значения присваиваются при каждом обращении к функции, в которой они описаны. Автоматические переменные, не инициализируемые явно, имеют неопределенные значения, (т.е. мусор). Внешние и статические переменные по умолчанию инициализируются нулем, но, тем не менее, их явная инициализация является признаком хорошего стиля.
Мы продолжим обсуждение вопросов инициализации, когда будем описывать новые типы данных.
Побитовые логические операции
В языке предусмотрен ряд операций для работы с битами; эти операции нельзя применять к переменным типа float или double.
| & | Побитовое AND |
| \! | Побитовое включающее OR |
| ^ | побитовое исключающее OR |
| << | сдвиг влево |
| >> | сдвиг вправо |
| \^ | дополнение (унарная операция) |
"\" имитирует вертикальную черту.
Побитовая операция and часто используется для маскирования некоторого множества битов; например, оператор
c = n & 0177
передает в 'с' семь младших битов n, полагая остальные равными нулю. Операция '|' побитового or используется для включения битов:
c = x | mask
устанавливает на единицу те биты в х, которые равны единице в mask.
Следует быть внимательным и отличать побитовые операции & и | от логических связок && и ||, которые подразумевают вычисление значения истинности слева направо. Например, если х=1, а y=2, то значение х&y равно нулю, в то время как значение x&&y равно единице./почему?/
Операции сдвига << и >> осуществляют соответственно сдвиг влево и вправо своего левого операнда на число битовых позиций, задаваемых правым операндом. Таким образом , х<<2 сдвигает х влево на две позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению на 4. Сдвиг вправо величины без знака заполняет освобождающиеся биты на некоторых машинах, таких как PDP-11, заполняются содержанием знакового бита /"арифметический сдвиг"/, а на других - нулем /"логический сдвиг"/.
Унарная операция \^ дает дополнение к целому; это означает , что каждый бит со значением 1 получает значение 0 и наоборот. Эта операция обычно оказывается полезной в выражениях типа
x & \^077
где последние шесть битов х маскируются нулем. Подчеркнем, что выражение x&\^077 не зависит от длины слова и поэтому предпочтительнее, чем, например, x&0177700, где предполагается, что х занимает 16 битов. Такая переносимая форма не требует никаких дополнительных затрат, поскольку \^077 является константным выражением и, следовательно, обрабатывается во время компиляции.
Чтобы проиллюстрировать использование некоторых операций с битами, рассмотрим функцию getbits(x,p,n), которая возвращает /сдвинутыми к правому краю/ начинающиеся с позиции р поле переменной х длиной n битов. Мы предполагаем, что крайний правый бит имеет номер 0, и что n и р - разумно заданные положительные числа. Например, getbits(х,4,3) возвращает сдвинутыми к правому краю биты, занимающие позиции 4,3 и 2.
getbits(x,p,n) /* get n bits from position p */ unsigned x, p, n; { return((x >> (p+1-n)) & \^(\^0 << n)); }
Операция x >> (p+1-n) сдвигает желаемое поле в правый конец слова. описание аргумента x как unsigned гарантирует, что при сдвиге вправо освобождающиеся биты будут заполняться нулями, а не содержимым знакового бита, независимо от того, на какой машине пропускается программа. Все биты константного выражения \^0 равны 1; сдвиг его на n позиций влево с помощью операции \^0<<n создает маску с нулями в n крайних правых битах и единицами в остальных; дополнение \^ создает маску с единицами в n крайних правых битах.
Упражнение 2-5
Переделайте getbits таким образом, чтобы биты отсчитывались слева направо.
Упражнение 2-6
Напишите программу для функции wordlength(), вычисляющей длину слова используемой машины, т.е. Число битов в переменной типа int. функция должна быть переносимой, т.е. Одна и та же исходная программа должна правильно работать на любой машине.
Упражнение 2-7
Напишите программу для функции rightrot(n,b), сдвигающей циклически целое n вправо на b битовых позиций.
Упражнение 2-8
Напишите программу для функции invert(x,p,n), которая инвертирует (т.е. заменяет 1 на 0 и наоборот) n битов x, начинающихся с позиции p, оставляя другие биты неизмененными.
Преобразование типов
Если в выражениях встречаются операнды различных типов, то они преобразуются к общему типу в соответствии с небольшим набором правил. В общем, автоматически производятся только преобразования, имеющие смысл, такие как, например, преобразование целого в плавающее в выражениях типа f+i. Выражения же, лишенные смысла, такие как использование переменной типа float в качестве индекса, запрещены.
Во-первых, типы char и int могут свободно смешиваться в арифметических выражениях: каждая переменная типа char автоматически преобразуется в int. Это обеспечивает значительную гибкость при проведении определеных преобразований символов. Примером может служить функция atoi, которая ставит в соответствие строке цифр ее численный эквивалент.
atoi(s) /* convert s to integer */ char s[]; { int i, n;
n = 0; for ( i = 0; s[i]>='0' && s[i]<='9'; ++i) n = 10 * n + s[i] - '0'; return(n); }
Kак уже обсуждалось в лекции №1, выражение
s[i] - '0'
имеет численное значение находящегося в s[i] символа, потому что значение символов '0', '1' и т.д. образуют возрастающую последовательность расположенных подряд целых положительных чисел.
char c; c = getchar(); if ( c == EOF) ...
На машине, которая не осуществляет знакового расширения, переменная 'с' всегда положительна, поскольку она описана как char, а так как EOF отрицательно, то условие никогда не выполняется. Чтобы избежать такой ситуации, мы всегда предусмотрительно использовали int вместо char для любой переменной, получающей значение от getchar.
Основная же причина использования int вместо char не связана с каким-либо вопросом о возможном знаковом расширении. просто функция getchar должна передавать все возможные символы (чтобы ее можно было использовать для произвольного ввода) и, кроме того, отличающееся значение EOF. Следовательно значение EOF не может быть представлено как char, а должно храниться как int.
Другой полезной формой автоматического преобразования типов является то, что выражения отношения, подобные i>j, и логические выражения, связанные операциями && и ||, по определению имеют значение 1, если они истинны, и 0, если они ложны. Таким образом, присваивание
isdigit = c >= '0' && c <= '9';
полагает isdigit равным 1, если с - цифра, и равным 0 в противном случае. (В проверочной части операторов if, while, for и т.д. "Истинно" просто означает "не нуль").
Неявные арифметические преобразования работают в основном, как и ожидается. В общих чертах, если операция типа + или *, которая связывает два операнда (бинарная операция), имеет операнды разных типов, то перед выполнением операции "низший" тип преобразуется к "высшему" и получается результат "высшего" типа. Более точно, к каждой арифметической операции применяется следующая последовательность правил преобразования.
типы char и short преобразуются в int, а float в double. Затем, если один из операндов имеет тип double, то другой преобразуется в double, и результат имеет тип double. В противном случае, если один из операндов имеет тип long, то другой преобразуется в long, и результат имеет тип long. В противном случае, если один из операндов имеет тип unsigned, то другой преобразуется в unsigned и результат имеет тип unsigned. В противном случае операнды должны быть типа int, и результат имеет тип int. Подчеркнем, что все переменные типа float в выражениях преобразуются в double; в "C" вся плавающая арифметика выполняется с двойной точностью.
Старшинство и порядок вычисления
В приводимой ниже таблице сведены правила старшинства и ассоциативности всех операций, включая и те, которые мы еще не обсуждали. Операции, расположенные в одной строке, имеют один и тот же уровень старшинства; строки расположены в порядке убывания старшинства. Так, например, операции *, / и % имеют одинаковый уровень старшинства, который выше, чем уровень операций + и -.
| () [] -> . | LEFT TO RIGHT |
| ! \^ ++ -- - (TYPE) * & SIZEOF | RIGHT TO LEFT |
| * / % | LEFT TO RIGHT |
| + - | LEFT TO RIGHT |
| << >> | LEFT TO RIGHT |
| < <= > >= | LEFT TO RIGHT |
| == != | LEFT TO RIGHT |
| & | LEFT TO RIGHT |
| ^ | LEFT TO RIGHT |
| | | LEFT TO RIGHT |
| && | LEFT TO RIGHT |
| || | LEFT TO RIGHT |
| ?: | RIGHT TO LEFT |
| = += -= ETC. | RIGHT TO LEFT |
| , (CHAPTER 3) | LEFT TO RIGHT |
Операции -> и . Используются для доступа к элементам структур; они будут описаны в лекции №6 вместе с sizeof (размер объекта). В лекции №5 обсуждаются операции * (косвенная адресация) и & (адрес ). Отметим, что уровень старшинства побитовых логических операций &, ^ и э ниже уровня операций == и !=. Это приводит к тому, что осуществляющие побитовую проверку выражения, подобные
if ((x & mask) == 0) ...
Для получения правильных результатов должны заключаться в круглые скобки.
Как уже отмечалось ранее, выражения, в которые входит одна из ассоциативных и коммутативных операций (*, +, &, ^, э), могут перегруппировываться, даже если они заключены в круглые скобки. В большинстве случаев это не приводит к каким бы то ни было расхождениям; в ситуациях, где такие расхождения все же возможны, для обеспечения нужного порядка вычислений можно использовать явные промежуточные переменные.
В языке "C", как и в большинстве языков, не фиксируется порядок вычисления операндов в операторе. Например в операторе вида
x = f() + g();
сначала может быть вычислено f, а потом g, и наоборот; поэтому, если либо f, либо g изменяют внешнюю переменную, от которой зависит другой операнд, то значение x может зависеть от порядка вычислений. Для обеспечения нужной последовательности промежуточные результаты можно опять запоминать во временных переменных.
Подобным же образом не фиксируется порядок вычисления аргументов функции, так что оператор
Строчная константа
Строчная константа - это последовательность, состоящая из нуля или более символов, заключенных в двойные кавычки, как, например,
"i am a string" /* я - строка */ или "" /* null string */ /* нуль-строка */
Кавычки не являются частью строки, а служат только для ее ограничения. те же самые условные последовательности, которые использовались в символьных константах, применяются и в строках; символ двойной кавычки изображается как \".
С технической точки зрения строка представляет собой массив, элементами которого являются отдельные символы. Чтобы программам было удобно определять конец строки, компилятор автоматически помещает в конец каждой строки нуль-символ \0. Такое представление означает, что не накладывается конкретного ограничения на то, какую длину может иметь строка, и чтобы определить эту длину, программы должны просматривать строку полностью. При этом для физического хранения строки требуется на одну ячейку памяти больше, чем число заключенных в кавычки символов. Следующая функция strlen(s) вычисляет длину символьной строки s не считая конечный символ \0.
strlen(s) /* return length of s */ char s[]; { int i;
i = 0; while (s[i] != '\0') ++i; return(i); }
Будьте внимательны и не путайте символьную константу со строкой, содержащей один символ: 'x' - это не то же самое, что "x". Первое - это отдельный символ, использованный с целью получения численного значения, соответствующего букве х в машинном наборе символов. Второе - символьная строка, состоящая из одного символа (буква х) и \0.
Типы и размеры данных
В языке C имеется только несколько основных типов данных: char один байт, в котором может находиться один символ из внутреннего набора символов. int Целое, обычно соответствующее естественному размеру целых в используемой машине. float С плавающей точкой одинарной точности. double С плавающей точкой двойной точности.
Кроме того имеется ряд квалификаторов, которые можно использовать с типом int: short (короткое), long (длинное) и unsigned (без знака). Квалификаторы short и long указывают на различные размеры целых. Числа без знака подчиняются законам арифметики по модулю 2 в степени n, где n - число битов в int; числа без знаков всегда положительны. описания с квалификаторами имеют вид:
short int x; long int y; unsigned int z;
Cлово int в таких ситуациях может быть опущено, что обычно и делается.
Количество битов, отводимых под эти объекты зависит от имеющейся машины; в таблице ниже приведены некоторые характерные значения.
| ASCII | ASCII | EBCDIC | ASCII | |
| char | 8-BITS | 9-BITS | 8-BITS | 8-BITS |
| int | 16 | 32 | 32 | 32 |
| short | 16 | 36 | 16 | 16 |
| long | 32 | 36 | 32 | 32 |
| float | 32 | 36 | 32 | 32 |
| double | 64 | 72 | 64 | 64 |
Цель состоит в том, чтобы short и long давали возможность в зависимости от практических нужд использовать различные длины целых; тип int отражает наиболее "естественный" размер конкретной машины. Как вы видите, каждый компилятор свободно интерпретирует short и long в соответствии со своими аппаратными средствами. Все, на что вы можете твердо полагаться, это то, что short не длиннее, чем long.
Типы, операции и выражения
Переменные и константы являются основными объектами, с которыми оперирует программа. описания перечисляют переменные, которые будут использоваться, указывают их тип и, возможно, их начальные значения. Операции определяют, что с ними будет сделано. Выражения объединяют переменные и константы для получения новых значений. Все это - темы настоящей лекции.
Условные выражения
операторы
if (a > b) z = a; else z = b;
конечно вычисляют в z максимум из а и в. Условное выражение, записанное с помощью тернарной операции "?:", предоставляет другую возможность для записи этой и аналогичных конструкций. В выражении
е1 ? Е2 : е3
сначала вычисляется выражение е1. Если оно отлично от нуля (истинно), то вычисляется выражение е2, которое и становится значением условного выражения. В противном случае вычисляется е3, и оно становится значением условного выражения. Каждый раз вычисляется только одно из выражения е2 и е3. Таким образом, чтобы положить z равным максимуму из а и в, можно написать
z = (a > b) ? a : b; /* z = max(a,b) */
Следует подчеркнуть, что условное выражение действительно является выражением и может использоваться точно так же, как любое другое выражение. Если е2 и е3 имеют разные типы, то тип результата определяется по правилам преобразования, рассмотренным ранее в этой лекции. Например, если f имеет тип float, а n - тип int, то выражение
(n > 0) ? f : n
Имеет тип double независимо от того, положительно ли n или нет.
Так как уровень старшинства операции ?: очень низок, прямо над присваиванием, то первое выражение в условном выражении можно не заключать в круглые скобки. Однако, мы все же рекомендуем это делать, так как скобки делают условную часть выражения более заметной.
Использование условных выражений часто приводит к коротким программам. Например, следующий ниже оператор цикла печатает n элементов массива, по 10 в строке, разделяя каждый столбец одним пробелом и заканчивая каждую строку (включая последнюю) одним символом перевода строки.
for (i = 0; i < n; i++) printf("%6d%c",a[i],(i%10==9 || i==n-1) ? '\n' : ' ')
Символ перевода строки записывается после каждого десятого элемента и после n-го элемента. За всеми остальными элементами следует один пробел. Хотя, возможно, это выглядит мудреным, было бы поучительным попытаться записать это, не используя условного выражения.
Упражнение 2-10
Перепишите программу для функции lower, которая переводит прописные буквы в строчные, используя вместо конструкции if-else условное выражение.
Цикл DO - WHILE
Как уже отмечалось в лекции 1, циклы while и for обладают тем приятным свойством, что в них проверка окончания осуществляется в начале, а не в конце цикла. Третий оператор цикла языка "C", do-while, проверяет условие окончания в конце, после каждого прохода через тело цикла; тело цикла всегда выполняется по крайней мере один раз. Синтаксис этого оператора имеет вид:
do оператор while (выражение)
Сначала выполняется оператор, затем вычисляется выражение. Если оно истинно, то оператор выполняется снова и т.д. Если выражение становится ложным, цикл заканчивается.
Как и можно было ожидать, цикл do-while используется значительно реже, чем while и for, составляя примерно пять процентов от всех циклов. Тем не менее, иногда он оказывается полезным, как, например, в следующей функции itoa, которая преобразует число в символьную строку (обратная функции atoi). Эта задача оказывается несколько более сложной, чем может показаться сначала. Дело в том, что простые методы выделения цифр генерируют их в неправильном порядке. Мы предпочли получить строку в обратном порядке, а затем обратить ее.
itoa(n,s) /*convert n to characters in s */ char s[]; int n; { int i, sign;
if ((sign = n) < 0) /* record sign */ n = -n; /* make n positive */ i = 0; do { /* generate digits in reverse order */ s[i++] = n % 10 + '0';/* get next digit */ } while ((n /=10) > 0); /* delete it */ if (sign < 0) s[i++] = '-' s[i] = '\0'; reverse(s); }
Цикл do-while здесь необходим, или по крайней мере удобен, поскольку, каково бы ни было значение n, массив s должен содержать хотя бы один символ. Мы заключили в фигурные скобки один оператор, составляющий тело do-while, хотя это и не обязательно, для того, чтобы торопливый читатель не принял часть while за начало оператора цикла while.
Упражнение 3-3
При представлении чисел в двоичном дополнительном коде наш вариант itoa не справляется с наибольшим отрицательным числом, т.е. со значением n равным -2 в степени м-1, где м размер слова. объясните почему. Измените программу так, чтобы она правильно печатала это значение на любой машине.
Упражнение 3-4
Напишите аналогичную функцию itob(n,s), которая преобразует целое без знака n в его двоичное символьное представление в s. Запрограммируйте функцию itoh, которая преобразует целое в шестнадцатеричное представление.
Упражнение 3-5
Напишите вариант itoa, который имеет три, а не два аргумента. Третий аргумент - минимальная ширина поля; преобразованное число должно, если это необходимо, дополняться слева пробелами, так чтобы оно имело достаточную ширину.
Циклы - WHILE и FOR
Мы уже сталкивались с операторами цикла while и for. В конструкции
while (выражение) оператор
вычисляется выражение. Если его значение отлично от нуля, то выполняется оператор и выражение вычисляется снова. Этот цикл продолжается до тех пор, пока значение выражения не станет нулем, после чего выполнение программы продолжается с места после оператора.
Оператор
for (выражение 1; выражение 2; выражение 3) оператор
эквивалентен последовательности
выражение 1; while (выражение 2) { оператор выражение 3; }
Грамматически все три компонента в for являются выражениями. Наиболее распространенным является случай, когда выражение 1 и выражение 3 являются присваиваниями или обращениями к функциям, а выражение 2 - условным выражением. любая из трех частей может быть опущена, хотя точки с запятой при этом должны оставаться. Если отсутствует выражение 1 или выражение 3, то оно просто выпадает из расширения. Если же отсутствует проверка, выражение 2, то считается, как будто оно всегда истинно, так что
for (;;) { ... }
является бесконечным циклом, о котором предполагается, что он будет прерван другими средствами (такими как break или return).
Использовать ли while или for - это, в основном дело вкуса. Например в
while ((c = getchar()) == ' ' \!\! c == '\n' \!\! c == '\t') ; /* skip white space characters */
нет ни инициализации, ни реинициализации, так что цикл while выглядит самым естественным.
Цикл for, очевидно, предпочтительнее там, где имеется простая инициализация и реинициализация, поскольку при этом управляющие циклом операторы наглядным образом оказываются вместе в начале цикла. Это наиболее очевидно в конструкции
for (i = 0; i < n; i++)
которая является идиомой языка "C" для обработки первых n элементов массива, аналогичной оператору цикла do в фортране и PL/1. Аналогия, однако, не полная, так как границы цикла могут быть изменены внутри цикла, а управляющая переменная сохраняет свое значение после выхода из цикла, какова бы ни была причина этого выхода. Поскольку компонентами for могут быть произвольные выражения, они не ограничиваются только арифметическими прогрессиями. Тем не менее является плохим стилем включать в for вычисления, которые не относятся к управлению циклом, лучше поместить их в управляемые циклом операторы.
В качестве большего по размеру примера приведем другой вариант функции atoi, преобразующей строку в ее численный эквивалент. Этот вариант является более общим; он допускает присутствие в начале символов пустых промежутков и знака + или -. (В лекции 4 приведена функция atof, которая выполняет то же самое преобразование для чисел с плавающей точкой).
Общая схема программы отражает форму поступающих данных:
пропустить пустой промежуток, если он имеется извлечь знак, если он имеется извлечь целую часть и преобразовать ее
Каждый шаг выполняет свою часть работы и оставляет все в подготовленном состоянии для следующей части. Весь процесс заканчивается на первом символе, который не может быть частью числа.
atoi(s) /* convert s to integer */ char s[]; { int i, n, sign; for(i=0;s[i]==' ' \!\! s[i]=='\n' \!\! s[i]=='\t';i++) ; /* skip white space */ sign = 1; if(s[i] == '+' \!\! s[i] == '-') /* sign */ sign = (s[i++]=='+') ? 1 : - 1; for( n = 0; s[i] >= '0' && s[i] <= '9'; i++) n = 10 * n + s[i] - '0'; return(sign * n); }
Преимущества централизации управления циклом становятся еще более очевидными, когда имеется несколько вложенных циклов. Следующая функция сортирует массив целых чисел по методу Шелла. Основная идея сортировки по шеллу заключается в том, что сначала сравниваются удаленные элементы, а не смежные, как в обычном методе сортировки. Это приводит к быстрому устранению большой части неупорядоченности и сокращает последующую работу. Интервал между элементами постепенно сокращается до единицы, когда сортировка фактически превращается в метод перестановки соседних элементов.
shell(v, n) /* sort v[0]...v[n-1] into increasing order */ int v[], n; { int gap, i, j, temp;
for (gap = n/2; gap > 0; gap /= 2) for (i = gap; i < n; i++) for (j=i-gap; j>=0 && v[j]>v[j+gap]; j-=gap) { temp = v[j]; v[j] = v[j+gap]; v[j+gap] = temp; } }
Здесь имеются три вложенных цикла. Самый внешний цикл управляет интервалом между сравниваемыми элементами, уменьшая его от n/2 вдвое при каждом проходе, пока он не станет равным нулю. Средний цикл сравнивает каждую пару элементов, разделенных на величину интервала; самый внутренний цикл переставляет любую неупорядоченную пару. Так как интервал в конце концов сводится к единице, все элементы в результате упорядочиваются правильно. Отметим, что в силу общности конструкции for внешний цикл укладывается в ту же самую форму, что и остальные, хотя он и не является арифметической прогрессией.
Последней операцией языка "C" является запятая ",", которая чаще всего используется в операторе for. Два выражения, разделенные запятой, вычисляются слева направо, причем типом и значением результата являются тип и значение правого операнда. Таким образом, в различные части оператора for можно включить несколько выражений, например, для параллельного изменения двух индексов. Это иллюстрируется функцией reverse(s), которая располагает строку s в обратном порядке на том же месте.
reverse(s) /* reverse string s in place */ char s[]; { int c, i, j;
ELSE - IF
Конструкция
if (выражение) оператор else if (выражение) оператор else if (выражение) оператор else оператор
встречается настолько часто, что заслуживает отдельного краткого рассмотрения. Такая последовательность операторов if является наиболее распространенным способом программирования выбора из нескольких возможных вариантов. выражения просматриваются последовательно; если какое-то выражение оказывается истинным, то выполняется относящийся к нему оператор, и этим вся цепочка заканчивается. Каждый оператор может быть либо отдельным оператором, либо группой операторов в фигурных скобках.
Последняя часть с else имеет дело со случаем, когда ни одно из проверяемых условий не выполняется. Иногда при этом не надо предпринимать никаких явных действий; в этом случае хвост
else оператор
может быть опущен, или его можно использовать для контроля, чтобы засечь "невозможное" условие.
Для иллюстрации выбора из трех возможных вариантов приведем программу функции, которая методом половинного деления определяет, находится ли данное значение х в отсортированном массиве v. Элементы массива v должны быть расположены в порядке возрастания. функция возвращает номер позиции (число между 0 и n-1), в которой значение х находится в v, и -1, если х не содержится в v.
binary(x, v, n) /* find x in v[0]...v[n-1] */ int x, v[], n; { int low, high, mid;
low = 0; high = n - 1; while (low <= high) { mid = (low + high) / 2; if (x < v[mid]) high = mid - 1; else if (x > v[mid]) low = mid + 1; else /* found match */ return(mid); } return(-1); }
Основной частью каждого шага алгоритма является проверка, будет ли х меньше, больше или равен среднему элементу v[mid]; использование конструкции else - if здесь вполне естественно.
Оператор CONTINUE
Оператор continue родственен оператору break, но используется реже; он приводит к началу следующей итерации охватывающего цикла (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).
Операторы и блоки
Такие выражения, как x=0, или i++, или printf(...), становятся операторами, если за ними следует точка с запятой, как, например,
x = 0; i++; printf(...);
В языке "C" точка с запятой является признаком конца оператора, а не разделителем операторов, как в языках типа алгола.
Фигурные скобки /( и /) используются для объединения описаний и операторов в составной оператор или блок, так что они оказываются синтаксически эквивалентны одному оператору. Один явный пример такого типа дают фигурные скобки, в которые заключаются операторы, составляющие функцию, другой - фигурные скобки вокруг группы операторов в конструкциях if, else, while и for (на самом деле переменные могут быть описаны внутри любого блока; мы поговорим об этом в лекции 4). Точка с запятой никогда не ставится после первой фигурной скобки, которая завершает блок.
Переключатель
оператор switch дает специальный способ выбора одного из многих вариантов, который заключается в проверке совпадения значения данного выражения с одной из заданных констант и соответствующем ветвлении. В лекции 1 мы привели программу подсчета числа вхождений каждой цифры, символов пустых промежутков и всех остальных символов, использующую последовательность if...else if...else. Вот та же самая программа с переключателем.
main() /* count digits,white space, others */ { int c, i, nwhite, nother, ndigit[10];
nwhite = nother = 0; for (i = 0; i < 10; i++) ndigit[i] = 0;
while ((c = getchar()) != EOF) switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': ndigit[c-'0']++; break; case ' ': case '\n': case '\t': nwhite++; break; default : nother++; break; } printf("digits ="); for (i = 0; i < 10; i++) printf(" %d", ndigit[i]); printf("\nwhite space = %d, other = %d\n", nwhite, nother);
Переключатель вычисляет целое выражение в круглых скобках (в данной программе - значение символа с) и сравнивает его значение со всеми случаями (case). Каждый случай должен быть помечен либо целым, либо символьной константой, либо константным выражением. Если значение константного выражения, стоящего после вариантного префикса case, совпадает со значением целого выражения, то выполнение начинается с этого случая. Если ни один из случаев не подходит, то выполняется оператор после префикса default. Префикс default является необязательным ,если его нет, и ни один из случаев не подходит, то вообще никакие действия не выполняются. Случаи и выбор по умолчанию могут располагаться в любом порядке. Все случаи должны быть различными.
Оператор break приводит к немедленному выходу из переключателя. Поскольку случаи служат только в качестве меток, то если вы не предпримите явных действий после выполнения операторов, соответствующих одному случаю, вы провалитесь на следующий случай. операторы break и return являются самым обычным способом выхода из переключателя. Как мы обсудим позже в этой лекции, оператор break можно использовать и для немедленного выхода из операторов цикла while, for и do.
Проваливание сквозь случаи имеет как свои достоинства, так и недостатки. К положительным качествам можно отнести то, что оно позволяет связать несколько случаев с одним действием, как было с пробелом, табуляцией и новой строкой в нашем примере. Но в то же время оно обычно приводит к необходимости заканчивать каждый случай оператором break, чтобы избежать перехода к следующему случаю. Проваливание с одного случая на другой обычно бывает неустойчивым, так как оно склонно к расщеплению при модификации программы. За исключением, когда одному вычислению соответствуют несколько меток, проваливание следует использовать умеренно.
Заведите привычку ставить оператор break после последнего случая (в данном примере после default), даже если это не является логически необходимым. В один прекрасный день, когда вы добавите в конец еще один случай, эта маленькая мера предосторожности избавит вас от неприятностей.
Упражнение 3-1
Напишите программу для функции expand(s, t), которая копирует строку s в t, заменяя при этом символы табуляции и новой строки на видимые условные последовательности, как \n и \т. Используйте переключатель.
Блочная структура
Язык "C" не является языком с блочной структурой в смысле PL/1 или алгола; в нем нельзя описывать одни функции внутри других.
переменные же, с другой стороны, могут определяться по методу блочного структурирования. описания переменных (включая инициализацию) могут следовать за левой фигурной скобкой,открывающей любой оператор, а не только за той, с которой начинается тело функции. переменные, описанные таким образом, вытесняют любые переменные из внешних блоков, имеющие такие же имена, и остаются определеннымидо соответствующей правой фигурной скобки. Например в
if (n > 0) { int i; /* declare a new i */ for (i = 0; i < n; i++) ... }
Областью действия переменной i является "истинная" ветвь if; это i никак не связано ни с какими другими i в программе.
Блочная структура влияет и на область действия внешних переменных. Если даны описания
int x;
f() { double x; ... }
То появление x внутри функции f относится к внутренней переменной типа double, а вне f - к внешней целой переменной. Это же справедливо в отношении имен формальных параметров:
int x; f(x) double x; { ... }
Внутри функции f имя x относится к формальному параметру, а не к внешней переменной.
Еще об аргументах функций
В лекции №1 мы уже обсуждали тот факт , что аргументы функций передаются по значению, т.е. вызванная функция получает свою временную копию каждого аргумента, а не его адрес. Это означает, что вызванная функция не может воздействовать на исходный аргумент в вызывающей функции. Внутри функции каждый аргумент по существу является локальной переменной, которая инициализируется тем значением, с которым к этой функции обратились.
Если в качестве аргумента функции выступает имя массива, то передается адрес начала этого массива; сами элементы не копируются. функция может изменять элементы массива, используя индексацию и адрес начала. Таким образом, массив передается по ссылке. В лекции №5 мы обсудим, как использование указателей позволяет функциям воздействовать на отличные от массивов переменные в вызывающих функциях.
Между прочим, несуществует полностью удовлетворительного способа написания переносимой функции с переменным числом аргументов. Дело в том, что нет переносимого способа, с помощью которого вызванная функция могла бы определить, сколько аргументов было фактически передано ей в данном обращении. Таким образом, вы, например, не можете написать действительно переносимую функцию, которая будет вычислять максимум от произвольного числа аргументов, как делают встроенные функции max в фортране и PL/1.
Обычно со случаем переменного числа аргументов безопасно иметь дело, если вызванная функция не использует аргументов, которые ей на самом деле не были переданы, и если типы согласуются. Самая распространенная в языке "C" функция с переменным числом - printf. Она получает из первого аргумента информацию, позволяющую определить количество остальных аргументов и их типы. функция printf работает совершенно неправильно, если вызывающая функция передает ей недостаточное количество аргументов, или если их типы не согласуются с типами, указанными в первом аргументе. Эта функция не является переносимой и должна модифицироваться при использовании в различных условиях.
Если же типы аргументов известны, то конец списка аргументов можно отметить, используя какое-то соглашение; например, считая, что некоторое специальное значение аргумента часто нуль) является признаком конца аргументов.
#define maxop 20 /* max size of operand, operАtor * #define number '0' /* signal that number found */ #define toobig '9' /* signal that string is too big *
main() /* reverse polish desk calculator */ /( int tupe; char s[maxop]; double op2,atof(),pop(),push();
while ((tupe=getop(s,maxop)) !=EOF); switch(tupe) /( case number: push(atof(s)); break; case '+': push(pop()+pop()); break; case '*': push(pop()*pop()); break; case '-': op2=pop(); push(pop()-op2); break; case '/': op2=pop(); if (op2 != 0.0) push(pop()/op2); else printf("zero divisor popped\n"); break; case '=': printf("\t%f\n",push(pop())); break; case 'c': clear(); break; case toobig: printf("%.20s ... is too long\n",s) break; /) /) #define maxval 100 /* maximum depth of val stack */
int sp = 0; /* stack pointer */ double val[maxval]; /*value stack */ double push(f) /* push f onto value stack */ double f; /( if (sp < maxval) return(val[sp++] =f); else /( printf("error: stack full\n"); clear(); return(0); /) /)
double pop() /* pop top value from steack */ /( if (sp > 0) return(val[--sp]); else /( printf("error: stack empty\n"); clear(); return(0); /) /)
clear() /* clear stack */ /( sp=0; /)
Команда C очищает стек с помощью функции clear, которая также используется в случае ошибки функциями push и pop. К функции getop мы очень скоро вернемся.
Как уже говорилось в лекции №1, переменная является внешней, если она определена вне тела какой бы то ни было функции. Поэтому стек и указатель стека, которые должны использоваться функциями push, pop и clear, определены вне этих трех функций. Но сама функция main не ссылается ни к стеку, ни к указателю стека - их участие тщательно замаскировано. В силу этого часть программы, соответствующая операции =, использует конструкцию
push(pop());
для того, чтобы проанализировать верхний элемент стека, не изменяя его.
Отметим также, что так как операции + и * коммутативны, порядок, в котором объединяются извлеченные операнды, несущественен, но в случае операций - и / необходимо различать левый и правый операнды.
Упражнение 4-3
Приведенная основная схема допускает непосредственное расширение возможностей калькулятора. Включите операцию деления по модулю /%/ и унарный минус. Включите команду "стереть", которая удаляет верхний элемент стека. Введите команды для работы с переменными. /Это просто, если имена переменных будут состоять из одной буквы из имеющихся двадцати шести букв/.
Инициализация
Мы до сих пор уже много раз упоминали инициализацию, но всегда мимоходом , среди других вопросов. Теперь, после того как мы обсудили различные классы памяти, мы в этом разделе просуммируем некоторые правила, относящиеся к инициализации.
Если явная инициализация отсутствует, то внешним и статическим переменным присваивается значение нуль; автоматические и регистровые переменные имеют в этом случае неопределенные значения (мусор).
Простые переменные (не массивы или структуры) можно инициализировать при их описании, добавляя вслед за именем знак равенства и константное выражение:
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; ... )
Макроподстановка
определение вида
#define tes 1
приводит к макроподстановке самого простого вида - замене имени на строку символов. Имена в #define имеют ту же самую форму, что и идентификаторы в "с"; заменяющий текст совершенно произволен. Нормально заменяющим текстом является остальная часть строки; длинное определение можно продолжить, поместив \ в конец продолжаемой строки. "Область действия" имени, определенного в #define, простирается от точки определения до конца исходного файла. Имена могут быть переопределены, и определения могут использовать определения, сделанные ранее. Внутри заключенных в кавычки строк подстановки не производятся, так что если, например, yes - определенное имя, то в printf("yes") не будет сделано никакой подстановки.
Так как реализация #define является частью работы макропредпроцессора, а не собственно компилятора, имеется очень мало грамматических ограничений на то, что может быть определено. Так, например, любители алгола могут объявить
#define then #define begin { #define end ;}
и затем написать
if (i > 0) then begin a = 1; b = 2 end
Имеется также возможность определения макроса с аргументами, так что заменяющий текст будет зависеть от вида обращения к макросу. Определим, например, макрос с именем max следующим образом:
#define max(a, b) ((a) > (b) ? (a) : (b))
когда строка
x = max(p+q, r+s);
будет заменена строкой
x = ((p+q) > (r+s) ? (p+q) : (r+s));
Такая возможность обеспечивает "функцию максимума", которая расширяется в последовательный код, а не в обращение к функции. При правильном обращении с аргументами такой макрос будет работать с любыми типами данных; здесь нет необходимости в различных видах max для данных разных типов, как это было бы с функциями.
Конечно, если вы тщательно рассмотрите приведенное выше расширение max, вы заметите определеные недостатки. Выражения вычисляются дважды; это плохо, если они влекут за собой побочные эффекты, вызванные, например, обращениями к функциям или использованием операций увеличения. Нужно позаботиться о правильном использовании круглых скобок, чтобы гарантировать сохранение требуемого порядка вычислений. (Рассмотрите макрос
Область действия
Областью действия имени является та часть программы, в которой это имя определено. Для автоматической переменной, описанной в начале функции, областью действия является та функция, в которой описано имя этой переменной, а переменные из разных функций, имеющие одинаковое имя, считаются не относящимися друг к другу. Это же справедливо и для аргументов функций.
Область действия внешней переменной простирается от точки, в которой она объявлена в исходном файле, до конца этого файла. Например, если val, sp, push, pop и clear определены в одном файле в порядке, указанном выше, а именно:
int sp = 0; double val[maxval];
double push(f) {...}
double pop() {...}
clear() {...}
то переменные val и sp можно использовать в push, pop и clear прямо по имени; никакие дополнительные описания не нужны.
С другой стороны, если нужно сослаться на внешнюю переменную до ее определения, или если такая переменная определена в файле, отличном от того, в котором она используется, то необходимо описание extern.
Важно различать описание внешней переменной и ее определение. описание указывает свойства переменной /ее тип, размер и т.д./; определение же вызывает еще и отведение памяти. Если вне какой бы то ни было функции появляются строчки
int sp; double val[maxval];
то они определяют внешние переменные sp и val, вызывают отведение памяти для них и служат в качестве описания для остальной части этого исходного файла. В то же время строчки
extern int sp; extern double val[];
описывают в остальной части этого исходного файла переменную sp как int, а val как массив типа double /размер которого указан в другом месте/, но не создают переменных и не отводят им места в памяти.
Во всех файлах, составляющих исходную программу, должно содержаться только одно определение внешней переменной; другие файлы могут содержать описания extern для доступа к ней. /описание extern может иметься и в том файле, где находится определение/. Любая инициализация внешней переменной проводится только в определении. В определении должны указываться размеры массивов, а в описании extern этого можно не делать.
Хотя подобная организация приведенной выше программы и маловероятна, но val и sp могли бы быть определены и инициализированы в одном файле, а функция push, pop и clear определены в другом. В этом случае для связи были бы необходимы следующие определения и описания:
в файле 1: ----------
int sp = 0; /* stack pointer */ double val[maxval]; /* value stack */
в файле 2: ----------
extern int sp; extern double val[];
double push(f) {...}
double pop() {...}
clear() {...}
так как описания extern 'в файле 1' находятся выше и вне трех указанных функций, они относятся ко всем ним; одного набора описаний достаточно для всего 'файла 2'.
Для программ большого размера обсуждаемая позже в этой лекции возможность включения файлов, #include, позволяет иметь во всей программе только одну копию описаний extern и вставлять ее в каждый исходный файл во время его компиляции.
Обратимся теперь к функции getop, выбирающей из файла ввода следующую операцию или операнд. Основная задача проста: пропустить пробелы, знаки табуляции и новые строки. Если следующий символ отличен от цифры и десятичной точки, то возвратить его. В противном случае собрать строку цифр /она может включать десятичную точку/ и возвратить number как сигнал о том, что выбрано число.
процедура существенно усложняется, если стремиться правильно обрабатывать ситуацию, когда вводимое число оказывается слишком длинным. функция getop считывает цифры подряд /возможно с десятичной точкой/ и запоминает их, пока последовательность не прерывается. Если при этом не происходит переполнения, то функция возвращает number и строку цифр. Если же число оказывается слишком длинным, то getop отбрасывает остальную часть строки из файла ввода, так что пользователь может просто перепечатать эту строку с места ошибки; функция возвращает toobig как сигнал о переполнении.
getop(s, lim) /* get next oprerator or operand */ char s[]; int lim; { int i, c;
while((c=getch())==' '\!\! c=='\t' \!\! c=='\n') ; if (c != '.' && (c < '0' \!\! c > '9')) return(c); s[0] = c; for(i=1; (c=getchar()) >='0' && c <= '9'; i++) if (i < lim)
s[i] = c; if (c == '.') { /* collect fraction */ if (i < lim) s[i] = c; for(i++;(c=getchar()) >='0' && c<='9';i++) if (i < lim) s[i] =c; } if (i < lim) { /* number is ok */ ungetch(c); s[i] = '\0'; return (number);
} else { /* it' s too big; skip rest of line */ while (c != '\n' && c != EOF) c = getchar(); s[lim-1] = '\0'; return (toobig); } }
Что же представляют из себя функции 'getch' и 'ungetch'? Часто так бывает, что программа, считывающая входные данные, не может определить, что она прочла уже достаточно, пока она не прочтет слишком много. Одним из примеров является выбор символов, составляющих число: пока не появится символ, отличный от цифры, число не закончено. Но при этом программа считывает один лишний символ, символ, для которого она еще не подготовлена.
Эта проблема была бы решена, если бы было бы возможно "прочесть обратно" нежелательный символ. Тогда каждый раз, прочитав лишний символ, программа могла бы поместить его обратно в файл ввода таким образом, что остальная часть программы могла бы вести себя так, словно этот символ никогда не считывался. к счастью, такое неполучение символа легко иммитировать, написав пару действующих совместно функций. функция getch доставляет следующий символ ввода, подлежащий рассмотрению; функция ungetch помещает символ назад во ввод, так что при следующем обращении к getch он будет возвращен.
То, как эти функции совместно работают, весьма просто. функция ungetch помещает возвращаемые назад символы в совместно используемый буфер, являющийся символьным массивом. функция getch читает из этого буфера, если в нем что-либо имеется; если же буфер пуст, она обращается к getchar. При этом также нужна индексирующая переменная, которая будет фиксировать позицию текущего символа в буфере.
Так как буфер и его индекс совместно используются функциями getch и ungetch и должны сохранять свои значения в период между обращениями, они должны быть внешними для обеих функций. Таким образом, мы можем написать getch, ungetch и эти переменные как:
#define bufsize 100 char buf[bufsize]; /* buffer for ungetch */ int bufp = 0; /* next free position in buf */
getch() /* get a (possibly pushed back) character */ { return((bufp > 0) ? buf[--bufp] : getchar()); }
Основные сведения
Для начала давайте разработаем и составим программу печати каждой строки ввода, которая содержит определенную комбинацию символов. /Это - специальный случай утилиты 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,t) возвращает позицию, или индекс, строки s, где начинается строка t, и -1, если s не содержит t. В качестве начальной позиции мы используем 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.с. Тогда команда
Правила, определяющие область действия
Функции и внешние переменные, входящие в состав "C"-программы, не обязаны компилироваться одновременно; программа на исходном языке может располагаться в нескольких файлах, и ранее скомпилированные процедуры могут загружаться из библиотек. Два вопроса представляют интерес:
Как следует составлять описания, чтобы переменные правильно воспринимались во время компиляции? Как следует составлять описания, чтобы обеспечить правильную связь частей программы при загрузке?
Препроцессор языка "C"
В языке "с" предусмотрены определеные расширения языка с помощью простого макропредпроцессора. одним из самых распространенных таких расширений, которое мы уже использовали, является конструкция #define; другим расширением является возможность включать во время компиляции содержимое других файлов.
Рекурсия
В языке "C" функции могут использоваться рекурсивно; это означает, что функция может прямо или косвенно обращаться к себе самой. Традиционным примером является печать числа в виде строки символов. как мы уже ранее отмечали, цифры генерируются не в том порядке: цифры младших разрядов появляются раньше цифр из старших разрядов, но печататься они должны в обратном порядке.
Эту проблему можно решить двумя способами. Первый способ, которым мы воспользовались в лекции №3 в функции itoa, заключается в запоминании цифр в некотором массиве по мере их поступления и последующем их печатании в обратном порядке. Первый вариант функции printd следует этой схеме.
printd(n) /* print n in decimal */ int n; { char s[10]; int i;
if (n < 0) { putchar('-'); n = -n; } i = 0; do { s[i++] = n % 10 + '0'; /* get next char */ } while ((n /= 10) > 0); /* discard it */ while (--i >= 0) putchar(s[i]); }
Альтернативой этому способу является рекурсивное решение, когда при каждом вызове функция printd сначала снова обращается к себе, чтобы скопировать лидирующие цифры, а затем печатает последнюю цифру.
printd(n) /* print n in decimal (recursive)*/ int n; ( int i;
if (n < 0) { putchar('-'); n = -n; } if ((i = n/10) != 0) printd(i); putchar(n % 10 + '0'); )
Когда функция вызывает себя рекурсивно, при каждом обращении образуется новый набор всех автоматических переменных, совершенно не зависящий от предыдущего набора. Таким образом, в printd(123) первая функция printd имеет n = 123. Она передает 12 второй printd, а когда та возвращает управление ей, печатает 3. Точно так же вторая printd передает 1 третьей (которая эту единицу печатает), а затем печатает 2.
Рекурсия обычно не дает никакой экономии памяти, поскольку приходится где-то создавать стек для обрабатываемых значений. Не приводит она и к созданию более быстрых программ. Но рекурсивные программы более компактны, и они зачастую становятся более легкими для понимания и написания. Рекурсия особенно удобна при работе с рекурсивно определяемыми структурами данных, например, с деревьями; хороший пример будет приведен в лекции №6.
Упражнение 4-7
Приспособьте идеи, использованные в printd для рекурсивного написания itoa; т.е. Преобразуйте целое в строку с помощью рекурсивной процедуры.
Упражнение 4-8
Напишите рекурсивный вариант функции reverse(s), которая располагает в обратном порядке строку s.
Статические переменные
Статические переменные представляют собой третий класс памяти, в дополнении к автоматическим переменным и extern, с которыми мы уже встречались.
Статические переменные могут быть либо внутренними, либо внешними. Внутренние статические переменные точно так же, как и автоматические, являются локальными для некоторой функции, но, в отличие от автоматических, они остаются существовать, а не появляются и исчезают вместе с обращением к этой функции. это означает, что внутренние статические переменные обеспечивают постоянное, недоступное извне хранение внутри функции. Символьные строки, появляющиеся внутри функции, как, например, аргументы printf, являются внутренними статическими.
Внешние статические переменные определены в остальной части того исходного файла, в котором они описаны, но не в каком-либо другом файле. Таким образом, они дают способ скрывать имена, подобные buf и bufp в комбинации getch-ungetch, которые в силу их совместного использования должны быть внешними, но все же не доступными для пользователей getch и ungetch, чтобы исключалась возможность конфликта. Если эти две функции и две переменные объединить в одном файле следующим образом
static char buf[bufsize]; /* buffer for ungetch */ static int bufp=0; /*next free position in buf */
getch() {...}
ungetch() {...}
то никакая другая функция не будет в состоянии обратиться к buf и bufp; фактически, они не будут вступать в конфликт с такими же именами из других файлов той же самой программы.
Статическая память, как внутренняя, так и внешняя, специфицируется словом static, стоящим перед обычным описанием. Переменная является внешней, если она описана вне какой бы то ни было функции, и внутренней, если она описана внутри некоторой функции.
Нормально функции являются внешними объектами; их имена известны глобально. возможно, однако, объявить функцию как static; тогда ее имя становится неизвестным вне файла, в котором оно описано.
В языке "C" "static" отражает не только постоянство, но и степень того, что можно назвать "приватностью". Внутренние статические объекты определены только внутри одной функции; внешние статические объекты /переменные или функции/ определены только внутри того исходного файла, где они появляются, и их имена не вступают в конфликт с такими же именами переменных и функций из других файлов.
Внешние статические переменные и функции предоставляют способ организовывать данные и работающие с ними внутренние процедуры таким образом, что другие процедуры и данные не могут прийти с ними в конфликт даже по недоразумению. Например, функции getch и ungetch образуют "модуль" для ввода и возвращения символов; buf и bufp должны быть статическими, чтобы они не были доступны извне. Точно так же функции push, pop и clear формируют модуль обработки стека; var и sp тоже должны быть внешними статическими.
Включение файлов
Для облегчения работы с наборами конструкций #define и описаний (среди прочих средств) в языке "с" предусмотрена возможность включения файлов. Любая строка вида
#include "filename"
заменяется содержимым файла с именем filename. (Кавычки обязательны). Часто одна или две строки такого вида появляются в начале каждого исходного файла, для того чтобы включить общие конструкции #define и описания extern для глобальных переменных. Допускается вложенность конструкций #include.
конструкция #include является предпочтительным способом связи описаний в больших программах. Этот способ гарантирует, что все исходные файлы будут снабжены одинаковыми определениями и описаниями переменных, и, следовательно, исключает особенно неприятный сорт ошибок. Естественно, когда какой-то включаемый файл изменяется, все зависящие от него файлы должны быть перекомпилированы.
Внешние переменные
Программа на языке "C" состоит из набора внешних объектов, которые являются либо переменными, либо функциями. Термин "внешний" используется главным образом в противопоставление термину "внутренний", которым описываются аргументы и автоматические переменные, определеные внутри функций. Внешние переменные определены вне какой-либо функции и, таким образом, потенциально доступны для многих функций. Сами функции всегда являются внешними, потому что правила языка "C" не разрешают определять одни функции внутри других. По умолчанию внешние переменные являются также и "глобальными", так что все ссылки на такую переменную, использующие одно и то же имя (даже из функций, скомпилированных независимо), будут ссылками на одно и то же. В этом смысле внешние переменные аналогичны переменным common в фортране и external в PL/1. Позднее мы покажем, как определить внешние переменные и функции таким образом, чтобы они были доступны не глобально, а только в пределах одного исходного файла.
В силу своей глобальной доступности внешние переменные предоставляют другую, отличную от аргументов и возвращаемых значений, возможность для обмена данными между функциями. Если имя внешней переменной каким-либо образом описано, то любая функция имеет доступ к этой переменной, ссылаясь к ней по этому имени.
В случаях, когда связь между функциями осуществляется с помощью большого числа переменных, внешние переменные оказываются более удобными и эффективными, чем использование длинных списков аргументов. Как, однако, отмечалось в лекции №1, это соображение следует использовать с определенной осторожностью, так как оно может плохо отразиться на структуре программ и приводить к программам с большим числом связей по данным между функциями.
Вторая причина использования внешних переменных связана с инициализацией. В частности, внешние массивы могут быть инициализированы, а автоматические нет. Мы рассмотрим вопрос об инициализации в конце этой лекции.
Третья причина использования внешних переменных обусловлена их областью действия и временем существования. Автоматические переменные являются внутренними по отношению к функциям; они возникают при входе в функцию и исчезают при выходе из нее. Внешние переменные, напротив, существуют постоянно. Они не появляются и не исчезают, так что могут сохранять свои значения в период от одного обращения к функции до другого. В силу этого, если две функции используют некоторые общие данные, причем ни одна из них не обращается к другой , то часто наиболее удобным оказывается хранить эти общие данные в виде внешних переменных, а не передавать их в функцию и обратно с помощью аргументов.
#define maxop 20 /* max size of operand, operАtor * #define number '0' /* signal that number found */ #define toobig '9' /* signal that string is too big *
main() /* reverse polish desk calculator */ /( int tupe; char s[maxop]; double op2,atof(),pop(),push();
while ((tupe=getop(s,maxop)) !=EOF); switch(tupe) /( case number: push(atof(s)); break; case '+': push(pop()+pop()); break; case '*': push(pop()*pop()); break; case '-': op2=pop(); push(pop()-op2); break; case '/': op2=pop(); if (op2 != 0.0) push(pop()/op2); else printf("zero divisor popped\n"); break; case '=': printf("\t%f\n",push(pop())); break; case 'c': clear(); break; case toobig: printf("%.20s ... is too long\n",s) break; /) /) #define maxval 100 /* maximum depth of val stack */
int sp = 0; /* stack pointer */ double val[maxval]; /*value stack */ double push(f) /* push f onto value stack */ double f; /( if (sp < maxval) return(val[sp++] =f); else /( printf("error: stack full\n"); clear(); return(0); /) /)
double pop() /* pop top value from steack */ /( if (sp > 0) return(val[--sp]); else /( printf("error: stack empty\n"); clear(); return(0); /) /)
clear() /* clear stack */ /( sp=0; /)
Команда C очищает стек с помощью функции clear, которая также используется в случае ошибки функциями push и pop. К функции getop мы очень скоро вернемся.
Как уже говорилось в лекции №1, переменная является внешней, если она определена вне тела какой бы то ни было функции. Поэтому стек и указатель стека, которые должны использоваться функциями push, pop и clear, определены вне этих трех функций. Но сама функция main не ссылается ни к стеку, ни к указателю стека - их участие тщательно замаскировано. В силу этого часть программы, соответствующая операции =, использует конструкцию
push(pop());
для того, чтобы проанализировать верхний элемент стека, не изменяя его.
Отметим также, что так как операции + и * коммутативны, порядок, в котором объединяются извлеченные операнды, несущественен, но в случае операций - и / необходимо различать левый и правый операнды.
Упражнение 4-3
Приведенная основная схема допускает непосредственное расширение возможностей калькулятора. Включите операцию деления по модулю /%/ и унарный минус. Включите команду "стереть", которая удаляет верхний элемент стека. Введите команды для работы с переменными. /Это просто, если имена переменных будут состоять из одной буквы из имеющихся двадцати шести букв/.
