Стилевое единство и идиомы
Чем логичнее и последовательнее оформлена программа, тем она лучше. Если форматирование кода меняется непредсказуемым образом: цикл просматривает массив то по возрастанию, то по убыванию, строки копируются то с помощью strcpy, то с помощью цикла for — все перечисленные вариации сбивают читателя с толку, и ему трудно понять, что в действительности происходит. Но если одни и те же вычисления всегда выполняются одинаково, то каждое отклонение от обычного стиля будет указывать на действительное различие, заслуживающее быть отмеченным.
Будьте последовательны в применении
отступов и фигурных скобок.
Отступы помогают воспринять структуру кода, но какой стиль расположения
лучше? Следует располагать открывающую фигурную скобку на той же строке,
что if, или на следующей? Программисты ведут нескончаемые споры о наилучшем
расположении текста кода, однако выбор конкретного стиля гораздо менее
важен, чем логичность и последовательность его применения во всем приложении.
Выберите себе раз и навсегда один стиль — лучше всего, конечно, наш —
и используйте его всегда, не тратьте времени на споры.
Стоит ли вставлять фигурные скобки, когда необходимости в них нет? Как и обычные скобки, дополнительные фигурные скобки могут разрешить неясные моменты и облегчить понимание структуры кода. Многие опытные программисты во имя все того же постоянства всегда заключают в фигурные скобки тела циклов и условных операторов. Однако если тело состоит лишь из одной строки, то скобки явно не нужны, и мы бы посоветовали их опустить. Впрочем, не забудьте вставить их в тех случаях, когда они помогут разрешить неясности с "висящим else", — подобная неопределенность хорошо иллюстрируется следующим примером:
В данном фрагменте выравнивание выполнено неправильно, поскольку ia самом
деле else относится к строке
if (day > 29)
и весь код работает неверно. Когда один if следует сразу за другим всегда используйте фигурные скобки:
Применение средств редактирования с поддержкой синтаксиса уменьшает вероятность
возникновения подобных ошибок.
В рассматриваемом примере даже после исправления отмеченной ошибки код трудно понять. В нем будет проще разобраться, если мы заведем переменную для хранения количества дней в феврале:
Код все еще неверен: 2000 год является високосным, а 1900-й и 2100-й —
не високосные. Тем не менее такая структура уже значительно проще доводится
до безупречной.
Кстати, если вы работаете над программой, которую писал кто-то другой, сохраняйте ее оригинальный стиль. При внесении изменений не применяйте свой стиль, даже если он вам больше нравится. Постоянство в форматировании программы гораздо важнее, чем ваше собственное, поскольку только оно сможет облегчить жизнь тем, кому придется вникать в способы функционирования этой программы.
Используйте идиомы для единства стиля. В языках программирования, как и в обычных языках, существуют свои идиомы — это устоявшиеся приемы, используемые опытными программистами для написания типичных фрагментов кода. Одна из центральных проблем, возникающих при изучении языка программирования, — необходимость привыкнуть к его идиомам.
Одной из наиболее типичных идиом является форма написания цикла. Рассмотрим код на С, C++ или Java для просмотра п элементов массива, например для их инициализации. Можно написать этот код так:
? 1 = 0;
? while (1 <= п-1)
? array[i++] =1.0;
или так:
? for (1=0; 1 < п; )
? аггау[1++] = 1.0;
или даже так:
for (i = n; --1 >~ 0; )
array[i] = 1.0;
Все три способа, в принципе, правильны, однако устоявшаяся, идиоматическая форма выглядит так:
for (1 = 0; i < n; i++)
array[i] = 1.0;
Выбор именно этой формы не случаен. При такой записи обходятся все п элементов массива, пронумерованные от 0 до n-1. Все управление циклом находится непосредственно в его заголовке; обход происходит в возрастающем порядке; для обновления переменной счетчика цикла используется типичная операция инкремента (++). После выхода индекс цикла имеет известное нам значение как раз за последним элементом массива. Те, для кого этот язык как родной, все понимают без пояснений и воспроизводят конструкцию не задумываясь.
В C++ и Java стандартный вариант включает еще и объявление переменной цикла:
for (int 1=0; i < n; i++)
array[i] = 1.0;
Вот как выглядит стандартный цикл для обхода списка в С:
for (р = list; р != NULL; р = p->next) .......
И опять все управляющие элементы цикла находятся непосредственно в выражении for.
Для бесконечного цикла мы предпочитаем конструкцию
for (;;)
однако популярна и конструкция
while (1)
........
Не используйте других форм, кроме двух приведенных.
Использование отступов также должно быть стандартным, можно сказать — идиоматичным. Вот такое необычное вертикальное расположение управляющих элементов цикла ухудшает читабельность кода, поскольку выглядит как три отдельных выражения, а не как единый заголовок цикла:
Стандартную форму записи цикла воспринять гораздо проще:
for (ар = агг; ар < агг+128; ар++)
*ар = 0;
Небрежно выбранное расположение отступов растянет код на несколько экранов или страниц, что также не улучшает его восприятие.
Еще.один стандартный прием — вставлять присваивание внутрь условия цикла:
while ((с = getchar()) != EOF)
putchar(c);
Выражение do-while используется гораздо реже, чем for и while, поскольку при его применении тело цикла исполняется как минимум один раз вне зависимости от условий, которые проверяются не в начале цикла, а в конце. Во многих случаях это становится причиной появления ошибки, ждущей своего часа, как, например, в следующем варианте цикла для getchar:
В этом случае в переменную будет записано мусорное значение, поскольку
проверка производится уже после вызова putchar. Цикл do-while стоит применять
только в тех случаях, когда тело цикла обязательно должно быть выполнено
хотя бы один раз; некоторые примеры подобных ситуаций мы рассмотрим несколько
позже.
Одно из преимуществ последовательного применения идиом состоит в том, что любой нестандартный цикл, потенциальный источник ошибок, сразу же привлечет внимание. Например:
Место в памяти выделяется для элементов в количестве nmemb — от iArray[0]
до iArray[nmemb-1 ], но, поскольку в условии цикла проверка производится
на "меньше или равно" (<=), цикл вылезет за границу массива
и испортит новой записью то, что хранится за пределами выделенной памяти.
К сожалению, ошибки подобного типа нередко можно обнаружить только после
того, как данные уже разрушены.
В С и C++ есть также идиомы для выделения места под строки и для работы с ними, а код, который их не использует, зачастую таит в себе ошибку:
Никогда не следует употреблять gets, поскольку не существует способа ограничить
размер вводимой информации. Это ведет к проблемам, связанным с безопасностью,
к которым мы вернемся в главе 6; там мы увидим, что всегда лучше использовать
fgets. Однако существует и еще одна проблема: функция strlen вычисляет
размер строки, не учитывая завершающего строку символа ' \0', а функция
st rcpy его копирует. Таким образом, выделяется недостаточно места, и
st rcpy пишет за пределами выделенной памяти. Стандартной формой является
следующая:
р = malloc(strlen(buf)+1);
strcpy(p, buf);
или
р = new char[strlen(buf)+1];
strcpy(p, buf);
в C++. Таким образом, если вы не видите +1, то стоит проверить все еще раз.
В Java такой проблемы нет, поскольку строки там не представляются в виде массивов, оканчивающихся на 0. Кроме того, индексы массивов проверяются, так что в Java выйти за границы массива невозможно.
В большинстве сред С и C++ предусмотрена библиотечная функция strdup, которая создает копию строки, используя для этого malloc и st rcpy, что гарантирует от обсуждавшейся чуть выше ошибки. К сожалению, st rdup не входит в стандарт ANSI С.
Кстати говоря, ни в первой, ни в окончательной версии не проверяется значение, возвращаемое функцией malloc. Мы опустили эту проверку для того, чтобы сфокусировать ваше внимание на теме данного раздела, однако в настоящей программе значения, возвращаемые функциями malloc, realloc, strdup, а также другими функциями, выделяющими память, должны в обязательном порядке проверяться.
Используйте цепочки else-if для многовариантных ветвлений. Стандартной формой записи многовариантного ветвления является последовательность операторов if. . .else if...else:
Условия читаются сверху вниз; по достижении первого условия, которое оказалось
верным, выполняется следующее за ним выражение, после чего оставшаяся
часть конструкции пропускается. Под выражением мы, естественно, понимаем
здесь либо одно выражение, либо группу выражений, заключенную в фигурные
скобки. Последнее else обрабатывает ситуацию "по умолчанию"
— когда ни одна из перечисленных альтернатив не была выбрана. Это замыкающее
else может быть опущено, если не предусматривается никаких действий "по
умолчанию", однако и в таком случае полезно оставить эту часть с
сообщением об ошибке, чтобы отловить условия, которых "не может быть
никогда".
Все операторы else стоит выровнять по вертикали, вместо того чтобы устанавливать каждое else на одном уровне с соответствующим ему if. Вертикальное выравнивание означает, что проверки производятся последовательно; кроме того, предотвращается выползание кода за правый край страницы.
Последовательность вложенных выражений if —. предвестник трудно читаемого кода, если не заведомых ошибок:
Последовательность условных операторов заставляет нас напрягаться, запоминая,
какие тесты в каком порядке следуют, с тем чтобы в нужной точке вставить
соответствующее событие (если мы еще в состоянии его вспомнить). Там,
где должно быть произведено хотя бы одно действие, лучше использовать
else if. Изменение порядка, в котором производятся проверки, ведет к тому,
что код становится более понятным, кроме того, мы избавляемся от утечки
ресурса, которая присутствовала в первой версии (файлы остались незакрытыми):
Мы производим проверки до тех пор, пока не находим первое выполненное
условие, совершаем соответствующее действие и опускаем все последующие
проверки. Правило тут такое: каждое действие должно быть расположено как
можно ближе к той проверке, с которой связано. Другими словами, каждый
раз, произведя проверку, совершите что-нибудь.
Попытки повторного использования уже написанных блоков кода ведут к появлению программ, похожих на затянутые узлы:
Здесь используется замысловатая последовательность перескоков в выражении-переключателе,
а все для того, чтобы избежать дублирования одной строки кода! В стандартной,
идиоматической форме каждый вариант должен оканчиваться выходом (break),
с редкими и обязательно откомментированными исключениями. Традиционную
структуру проще воспринимать, хотя она и получается несколько длиннее:
Некоторое удлинение кода с лихвой окупается увеличением ясности. В данной
конкретной ситуации, однако, применение последовательности выражений else-if
будет даже более понятным:
В этом примере фигурные скобки вокруг блока из одной строки подчеркивают,
что структура выражения параллельна.
Использование перескоков оправдано в случае, когда несколько условий имеют одинаковый код. Тогда их размещают таким образом:
При такой записи комментарии не нужны.
Упражнение 1-7
Перепишите выражения C/C++ более понятным образом:
Упражнение 1-8
Найдите ошибки в этом фрагменте кода на языке Java и исправьте их, переписав цикл в стандартной форме: