Учебное введение

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

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

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

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

Содержание

1.1. Нaчинаем
1.2. Переменные и арифметика
1.3. Оператор for
1.4. Символьные константы
1.5. Набор полезных программ
1.5.1. Ввод и вывод символов
1.5.2. Копирование файла
1.5.3. Подсчет символов
1.5.4. Подсчет строк
1.5.5. Подсчет слов
1.6. Массивы
1.7. Функции.
1.8. Аргументы - вызов по значению.
1.9. Массивы символов.
1.10. Область действия: внешние переменные.
1.11. Резюме


Нaчинаем

Eдинственный способ освоить новый язык программирования - писать на нем программы. Первая программа, которая должна быть написана, - одна для всех языков:

Напечатать слова:


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

Программа печати "hello, world" на языке "C" имеет вид:


main()
{
        printf("hello, world\n");
}

Как пропустить эту программу - зависит от используемой вами системы. В частности, на операционной системе "UNIX" вы должны завести исходную программу в файле, имя которого оканчивается на ".c", например, hello.c, и затем скомпилировать ее по команде


cc hello.c

Eсли вы не допустили какой-либо небрежности, такой как пропуск символа или неправильное написание, компиляция пройдет без сообщений и будет создан исполняемый файл с именем а.out. Прогон его по команде


a.out
приведет к выводу

hello, world

На других системах эти правила будут иными; проконсультируйтесь с местным авторитетом.

Упражнение 1-1.
Пропустите эту программу на вашей системе. Попробуйте не включать различные части программы и посмотрите какие сообщения об ошибках вы при этом получите.

Теперь некоторые пояснения к самой программе. Любая "C"-программа, каков бы ни был ее размер, состоит из одной или более "функций", указывающих фактические операции компьютера, которые должны быть выполнены. Функции в языке "C" подобны функциям и подпрограммам фортрана и процедурам pl/1, паскаля и т.д. в нашем примере такой функцией является main. Обычно вы можете давать функциям любые имена по вашему усмотрению, но main - это особое имя; выполнение вашей программы начинается сначала с функции main. Это означает, что каждая программа должна в каком-то месте содержать функцию с именем main. Для выполнения определенных действий функция main обычно обращается к другим функциям, часть из которых находится в той же самой программе, а часть - в библиотеках, содержащих ранее написанные функции.

Одним способом обмена данными между функциями является передача посредством аргументов. Круглые скобки, следующие за именем функции, заключают в себе список аргументов; здесь маin - функция без аргументов, что указывается как (). Операторы, составляющие функцию, заключаются в фигурные скобки '{' и '}', которые аналогичны DO-END в pl/1 или begin-end в алголе, паскале и т.д. Обращение к функции осуществляется указанием ее имени, за которым следует заключенный в круглые скобки список аргументов. Здесь нет никаких операторов call, как в фортране или pl/1. круглые скобки должны присутствовать и в том случае, когда функция не имеет аргументов.

Строка


printf("hello, world\n");
является обращением к функции, которое вызывает функцию с именем printf и аргуметом "hello, world\n". Функция printf является библиотечной функцией, которая выдает выходные данные на терминал (если только не указано какоe-то другое место назначения). В данном случае печатается строка символов, являющаяся аргументом функции.

Последовательность из любого количества символов, заключенных в двойные кавычки "...", называется 'символьной строкой' или 'строчной константой'. Пока мы будем использовать символьные строки только в качестве аргументов для printf и других функций.

Последовательность \n в приведенной строке является обозначением на языке "C" для 'символа новой строки', который служит указанием для перехода на терминале к левому краю следующей строки. Если вы не включите \n (полезный эксперимент), то обнаружите, что ваша выдача не закончится переходом терминала на новую строку. Использование последовательности \n - единственный способ введения символа новой строки в аргумент функции printf ; если вы попробуете что-нибудь вроде:


printf("hello, world
  ");
тo "C"-компилятор будет печатать злорадные диагностические сообщения о недостающих кавычках.

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


main()
{
        printf("hello, ");
        printf("world");
        printf("\n");
}

Подчеркнем, что \n представляет только один символ. Условные 'последовательности', подобные \n, дают общий и допускающий расширение механизм для представления трудных для печати или невидимых символов. Среди прочих символов в языке "C" предусмотрены следующие:

\t - для табуляции,
\b - для возврата на одну позицию, " - для двойной кавычки и \\ для самой обратной косой черты.
Упражнение 1-2.
Проведите эксперименты для того, чтобы узнать что произойдет, если в строке, являющейся аргументом функции printf будет содержаться \x, где x - некоторый символ, не входящий в вышеприведенный список.


Переменные и арифметика

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


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 oзначает, что все переменные списка целые; тип float предназначен для чисел с плавающей точкой, т.е. для чисел, которые могут иметь дробную часть. Точность как int, tak и float зависит от конкретной машины, на которой вы работаете. На pdp-11, например, тип int соответствует 16-битовому числу со знаком, т.е. числу, лежащему между -32768 и +32767. Число типа float - это 32-битовое число, имеющее около семи значащих цифр и лежащее в диапазоне от 10e-38 до 10e+38. В главе 2 приводится список размеров для других машин.

В языке "C" предусмотрено несколько других основных типов данных, кроме int и float:

char символ - один байт
short короткое целое
long длинное целое
double плавающее с двойной точностью

Размеры этих об'ектов тоже машинно-независимы; детали приведены в главе 2. Имеются также массивы, структуры и об'единения этих основных типов, указатели на них и функции, которые их возвращают; со всеми ними мы встретимся в свое время.

Фактически вычисления в программе перевода температур начинаются с операторов присваивания


lower = 0;
upper = 300;
step = 20;
fahr = lower;
которые придают переменным их начальные значения. Каждый отдельный оператор заканчивается точкой с запятой.

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


while (fahr <= upper) {
        ....
}
проверяется условие в круглых скобках. Eсли оно истинно (fahr меньше или равно upper), то выполняется тело цикла (все операторы, заключенные в фигурные скобки). Затем вновь проверяется это условие и, если оно истинно, опять выполняется тело цикла. Если же условие не выполняется ( fahr превосходит upper ), цикл заканчивается и происходит переход к выполнению оператора, следующего за оператором цикла. Так как в настоящей программе нет никаких последующих операторов, то выполнение программы завершается.

Тело оператора while может состоять из одного или более операторов, заключенных в фигурные скобки, как в программе перевода температур, или из одного оператора без скобок, как, например, в


while (i < j)
        i = 2 * i;
В обоих случаях операторы, управляемые оператором while, сдвинуты на одну табуляцию, чтобы вы могли с первого взгляда видеть, какие операторы находятся внутри цикла. Tакой сдвиг подчеркивает логическую структуру программы. Хотя в языке "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 - для символьной строки и %% - для самого символа %.

Каждая конструкция с символом % в первом аргументе функции printf сочетается с соответствующим вторым, третьим, и т.д. аргументами; они должны согласовываться по числу и типу; в противном случае вы получите бессмысленные результаты.

Между прочим, функция printf не является частью языка "C"; в самом языке "C" не определены операции ввода-вывода. Нет ничего таинственного и в функции printf; это - просто полезная функция, являющаяся частью стандартной библиотеки подпрограмм, которая обычно доступна "C"-программам. Чтобы сосредоточиться на самом языке, мы не будем подробно останавливаться на операциях ввода-вывода до главы 7. В частности, мы до тех пор отложим форматный ввод. Если вам надо ввести числа - прочитайте описание функции scanf в главе 7, раздел 7.4. Функция scanf во многом сходна с printf, но она считывает входные данные, а не печатает выходные.

Упражнение 1-3.
Преобразуйте программу перевода температур таким образом, чтобы она печатала заголовок к таблице.

Упражнение 1-4.
Напишите программы печати соответствующей таблицы перехода от градусов Цельсия к градусам Фаренгейта.


Оператор 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, а не в виде отдельного оператора присваивания.

Последнее изменение является примером вполне общего правила языка "Си" - в любом контексте, в котором допускается использование значения переменной некоторого типа, вы можете использовать выражение этого типа. Так как третий аргумент функции printf должен иметь значение с плавающей точкой, чтобы соответствовать спецификации %6.1f, то в этом месте может встретиться любое выражение плавающего типа.

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


fahr = 0
выполняется один раз перед входом в сам цикл. Вторая часть - проверка, Aли условие, которое управляет циклом:

fahr <= 300

Это условие проверяется и, если оно истинно, то выполняется тело цикла (в данном случае только функция printf ). Затем выполняется шаг реинициализации


fahr = fahr + 20
и условие проверяется снова. Цикл завершается, когда это условие становится ложным. Так же, как и в случае оператора while, тело цикла может состоять из одного оператора или из группы операторов, заключенных в фигурные скобки. Инициализирующая и реинициализирующая части могут быть любыми отдельными выражениями.

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

Упражнение 1-5
Модифицируйте программу перевода температур таким образом, чтобы она печатала таблицу в обратном порядке, т.е. от 300 градусов до 0.


Символьные константы

Последнее замечание, прежде чем мы навсегда оставим программу перевода температур. Прятать "магические числа", такие как 300 и 20, внутрь программы - это неудачная практика; они дают мало информации тем, кто, возможно, должен будет разбираться в этой программе позднее, и их трудно изменять систематическим образом. К счастью в языке "C" предусмотрен способ, позволяющий избежать таких "магических чисел". Используя конструкцию #define, вы можете в начале программы определить символическое имя или символическую константу, которая будет конкретной строкой символов. Впоследствии компилятор заменит все не заключенные в кавычки появления этого имени на соответствующую строку. Фактически это имя может быть заменено абсолютно произвольным текстом, не обязательно цифрами


#define lower 0                 /* lower limit of table */
#define upper 300               /* upper limit */
#define step 20                 /* step size */
main()
{                               /* fahrenheit-celsius
                                 * table */
        int fahr;
        for (fahr = lower; fahr <= upper; fahr = fahr + step)
                printf("%4d %6.1f\n",
                fahr, (5.0 / 9.0) * (fahr - 32));
}

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


Набор полезных программ

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

Ввод и вывод символов

Стандартная библиотека включает функции для чтения и записи по одному символу за один раз. Функция getchar() извлекает следующий вводимый символ каждый раз, как к ней обращаются, и возвращает этот символ в качестве своего значения. Это значит, что после


c = getchar();

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

Функция putchar(с) является дополнением к getchar : в результате обращения


putchar (с);
содержимое переменной 'с' выдается на некоторый выходной носитель, обычно опять на терминал. Обращение к функциям putchar и printf могут перемежаться; выдача будет появляться в том порядке, в котором происходят обращения.

Как и функция printf, функции getchar и putchar не содержат ничего экстраординарного. Они не входят в состав языка "C", но к ним всегда можно обратиться.

Копирование файла

Имея в своем распоряжении только функции getchar и putchar Вы можете, не зная ничего более об операциях ввода-вывода, написать удивительное количество полезных программ. Простейшим примером может служить программа посимвольного копирования вводного файла в выводной. Общая схема имеет вид:


ввести символ
while (символ не является признаком конца файла)
вывести только что прочитанный символ
ввести новый символ

Программа, написанная на языке "Си", выглядит следующим образом:


#include <stdio.h>
main()
{                               /* copy input tо 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();

может быть использовано в выражении; его значение - просто значение, присваиваемое левой части. Если присваивание символа переменной 'с' поместить внутрь проверочной части оператора while, то программа копирования файла запишется в виде:


main()
{                               /* copy input то output;
                                 * 2nd version */
        int c;
        while ((c = getchar()) != EOF)
                putchar(c);
}

Программа извлекает символ, присваивает его переменной 'c' и затем проверяет, не является ли этот символ признаком конца файла. Если нет - выполняется тело оператора while, выводящее этот символ. Затем цикл while повторяется. Когда, наконец, будет достигнут конец файла ввода, оператор while завершается, а вместе с ним заканчивается выполнение и функции main.

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

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


c = getchar() != EOF
эквивалентен оператору

c = (getchar() != EOF)

Это, вопреки нашему желанию, приведет к тому, что 'c' будет принимать значение 0 или 1 в зависимости от того, натолкнется или нет getchar на признак конца файла. (Подробнее об этом будет сказано в главе 2.)"

Подсчет символов

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


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

Подсчет строк

Следующая программа подсчитывает количество строк в файле ввода. Предполагается, что строки ввода заканчиваются символом новой строки \n, скрупулезно добавленным к каждой выписанной строке.


main()
{                               /* count lines in input */
        int            с, nl;

        nl = 0;
        while ((с= getchar()) != EOF)
                if (с== '\n')
                        ++nl;
        printf("%d\n", nl);
}

Тело while теперь содержит оператор if, который в свою очередь управляет оператором увеличения ++nl. Оператор if проверяет заключенное в круглые скобки условие и, если оно истинно, выполняет следующий за ним оператор (или группу операторов, заключенных в фигурные скобки). Мы опять использовали сдвиг вправо, чтобы показать, что чем управляет.

Удвоенный знак равенства == является обозначением в языке "C" для "равно" (аналогично .eq. в фортране). Этот символ введен для того, чтобы отличать проверку на равенство от одиночного =, используемого при присваивании. Поскольку в типичных "C"-программах знак присваивания встречается примерно в два раза чаще, чем проверка на равенство, то естественно, чтобы знак оператора был вполовину короче.

Любой отдельный символ может быть записан внутри одиночных кавычек, и при этом ему соответствует значение, равное численному значению этого символа в машинном наборе символов; это называется символьной константой. Так, например, 'a' - символьная константа; ее значение в наборе символов ascii (американский стандартный код для обмена информацией) равно 65, внутреннему представлению символа a. Конечно, 'a' предпочтительнее, чем 65: его смысл очевиден и он не зависит от конкретного машинного набора символов.

Условные последовательности, используемые в символьных строках, также занимают законное место среди символьных констант. Так в проверках и арифметических выражениях '\n' представляет значение символа новой строки. Вы должны твердо уяснить, что '\n' - отдельный символ, который в выражениях эквивалентен одиночному целому; с другой стороны "\n" - это символьная строка, которая содержит только один символ. Вопрос о сопоставлении строк и символов обсуждается в < a href="ch02.html#symconstvstring">главе 2.

Упражнение 1-6.
Напишите программу для подсчета пробелов, табуляций и новых строк.

Упражнение 1-7.
Напишите программу, которая копирует ввод на вывод, заменяя при этом каждую последовательность из одного или более пробелов на один пробел.

Подсчет слов

Четвертая программа из нашей серии полезных программ подсчитывает количество строк, слов и символов, используя при этом весьма широкое определение, что словом является любая последовательность символов, не содержащая пробелов, табуляций или новых строк. (Это - упрощенная версия утилиты 'wc' системы 'UNIX').


#define yes 1
#define no 0

main()
{                               /* count lines, words,
                                 * chars in input */
        int             c, nl, nw, inword;

        inword = no;
        nl = nw = nc = 0;
        while ((c = getchar()) != EOF) {
                ++nc;
                if (с== '\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 = (n = (nw = 0));
операция || означает OR, так что строка

if (c == ' ' || c == '\n' || c == '\t')
говорит "если c - пробел, или c - символ новой строки, или c -табуляция ...". (Условная последовательность \t является изображением символа табуляции).

Имеется соответствующая операция && для AND. Выражения, связанные операциями && или ||, рассматриваются слева на право, и при этом гарантируется, что оценивание выражений будет прекращено, как только станет ясно, является ли все выражение истинным или ложным. Так, если 'c' оказывается пробелом, то нет никакой необходимости проверять, является ли 'c' символом новой строки или табуляции, и такие проверки действительно не делаются. В данном случае это не имеет принципиального значения, но, как мы скоро увидим, в более сложных ситуациях эта особенность языка весьма существенна.

Этот пример также демонстрирует операСор else языка "C", который указывает то действие, которое должно выполняться, если условие, содержащееся в операторе if, окажется ложным. Общая форма такова:


if (выражение)
        оператор-1
else
        оператор-2

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

Упражнение 1-9.
Как бы вы стали проверять программу подсчета слов ? Какие имеются ограничения ?

Упражнение 1-10.
Напишите программу, которая будет печатать слова из файла ввода, причем по одному на строку.

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


Массивы

Давайте напишем программу подсчета числа появлений каждой цифры, символов пустых промежутков (пробел, табуляции, новая строка) и всех остальных символов. Конечно, такая задача несколько искусственна, но она позволит нам проиллюстрировать в одной программе сразу несколько аспектов языка "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' && с<='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. Это вполне естественно и удобно; например, с -'0'- это целое выражение со значением между 0 и 9 в соответствии с тем, какой символ от '0' до '9' хранится в 'с', и, следовательно, оно является подходящим индексом для массива ndigit.

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


if (c >= '0' && c <= '9')
        ++ndigit[c - '0'];
else if (c == ' ' || c == '\n' || c == '\t')
        ++nwhite;
else
        ++nother;
Конструкции

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

Программа просто движется сверху вниз до тех пор, пока не удовлетворится какоe-нибудь условие; тогда выполняется соответствующий 'оператор', и вся конструкция завершается (конечно, 'оператор' может состоять из нескольких операторов, заключенных в фигурные скобки). Если ни одно из условий не удовлетворяется, то выполняется 'оператор', стоящий после заключительного else, если оно присутствует. Если последнее else и соответствующий 'оператор' опущены (как в программе подсчета слов), то никаких действий не производится. Между начальным if и конечным else может помещаться произвольное количество групп


else if (условие)
        оператор

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

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

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


Функции.

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

До сих пор мы использовали только предоставленные нам функции типа printf, getchar и putchar; теперь пора написать несколько наших собственных. Так как в "C" нет операции возведения в степень, подобной операции ** в фортране или pl/1, давайте проиллюстрируем механику определения функции на примере функции power(м,n), возводящей целое м в целую положительную степень 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);
}
Все функции имеют одинаковый вид:

имя (список аргументов, если они имеются)
описание аргументов, если они имеются
{
        описания

        операторы
}

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

Функция 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. Внутри круглых скобок можно написать любое выражение. Функция не обязана возвращать какоe-либо значение; оператор return, не содержащий никакого выражения, приводит к такой же передаче управления, как "сваливание на конец" функции при достижении конечной правой фигурной скобки, но при этом в вызывающую функцию не возвращается никакого полезного значения.

Упражнение 1-13.
Напишите программу преобразования прописных букв из файла ввода в строчные, используя при этом функцию lower(c), которая возвращает значение 'c', если 'c' - не буква, и значение соответствующей строчной буквы, если 'c'-буква.


Аргументы - вызов по значению.

Один аспект в "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" является массив символов. Чтобы проиллюстрировать использование массивов символов и обрабатывающих их функций, давайте напишем программу, которая читает набор строк и печатает самую длинную из них. Основная схема программы достаточно проста:


while (имеется еще строка)
if (эта строка длиннее самой длинной из предыдущих)
        запомнить эту строку и ее длину
напечатать самую длинную строку

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

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

Когда мы находим строку, которая длиннее самой длинной из предыдущих, то ее надо гдe-то запомнить. Это наводит на мысль о другой функции, 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, могли зафиксировать конец массива:

hello\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 и мах внешними переменными. Это потребует изменения описаний и тел всех трех функций, а также обращений к ним.


#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;
        if (c == '\n') {
                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 довольно неуклюжа. Перепишите программу таким образом, чтобы сделать эту проверку более ясной, но сохраните при этом то же самое поведение в конце файла и при переполнении буфера. Является ли это поведение самым разумным?


Резюме

На данном этапе мы обсудили то, что можно бы назвать традиционным ядром языка "C". Имея эту горсть строительных блоков, можно писать полезные программы весьма значительного размера, и было бы вероятно неплохой идеей, если бы вы задержались здесь на какоe-то время и поступили таким образом: следующие ниже упражнения предлагают вам ряд программ несколько большей сложности, чем те, которые были приведены в этой главе.

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

Упражнение 1-19.
Напишите программу detab, которая заменяет табуляции во вводе на нужное число пробелов так, чтобы промежуток достигал следующей табуляционной остановки. Предположите фиксированный набор табуляционных остановок, например, через каждые n позиций.

Упражнение 1-20.
Напишите программу entab, которая заменяет строки пробелов минимальным числом табуляций и пробелов, достигая при этом тех же самых промежутков. Используйте те же табуляционные остановки, как и в detab.

Упражнение 1-21.
Напишите программу для "сгибания" длинных вводимых строк после последнего отличного от пробела символа, стоящего до столбца n ввода, где n - параметр. Убедитесь, что ваша программа делает что-то разумное с очень длинными строками и в случае, когда перед указанным столбцом нет ни табуляций, ни пробелов.

Упражнение 1-22.
Напишите программу удаления из "C"-программы всех комментариев. Не забывайте аккуратно обращаться с "закавыченными" строками и символьными константами.

Упражнение 1-23.
Напишите программу проверки "Си"-программы на элементарные синтаксические ошибки, такие как несоответствие круглых, квадратных и фигурных скобок. Не забудьте о кавычках, как одиночных, так и двойных, и о комментариях. (эта программа весьма слложна , если вы будете писать ее для самого общего случая).


Наш баннер
Вы можете установить наш баннер на своем сайте или блоге, скопировав этот код:
RSS новости