?n=1

?printf(."%d %d\n", n++, n++);

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

Стилевое единство и идиомы

Чем логичнее и последовательнее оформлена программа, тем она лучше. Если форматирование кода меняется непредсказуемым образом: цикл просматривает массив то по возрастанию, то по убыванию, строки копируются то с помощью strcpy, то с помощью цикла for — все перечисленные вариации сбивают читателя с толку, и ему трудно понять, что в действительности происходит. Но если одни и те же вычисления всегда выполняются одинаково, то каждое отклонение от обычного стиля будет указывать на действительное различие, заслуживающее быть отмеченным.

Будьте последовательны в применении отступов и фигурных скобок.

Отступы помогают воспринять структуру кода, но какой стиль расположения лучше? Следует располагать открывающую фигурную скобку на той же строке, что if, или на следующей? Программисты ведут нескончаемые споры о наилучшем расположении текста кода, однако выбор конкретного стиля гораздо менее важен, чем логичность и последовательность его применения во всем приложении. Выберите себе раз и навсегда один стиль — лучше всего, конечно, наш — и используйте его всегда, не тратьте времени на споры.

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

if (month == FEB) { if (year%4 == 0) if (day > 29) legal = FALSE; else

if (day > 28) legal = FALSE;

В данном фрагменте выравнивание выполнено неправильно, поскольку ia самом деле else относится к строке

if (day > 29)

и весь код работает неверно. Когда один if следует сразу за другим всегда используйте фигурные скобки:

?if (month == FEB) {

?if (year%4 == 0) {

?if (day > 29)

?legal = FALSE;

?} else {

?if (day > 28)

?legal = FA*LSE;

Применение средств редактирования с поддержкой синтаксиса уменьшает вероятность возникновения подобных ошибок.

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

? if (month == FEB) { ? int nday;

?

? nday = 28;

?if (year%4 == 0) ? nday = 29;

?if (day > nday) 9 legal = FALSE; ?}

Код все еще неверен: 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 (;;)

однако популярна и конструкция

........

Не используйте других форм, кроме двух приведенных.

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

for (

ар = агг;

ар < агг + 128; *ар++ = О

)

{

;

}

Стандартную форму записи цикла воспринять гораздо проще:

for (ар = агг; ар < агг+128; ар++) *ар = 0;

Небрежно выбранное расположение отступов растянет код на несколько экранов или страниц, что также не улучшает его восприятие.

Еще.один стандартный прием — вставлять присваивание внутрь условия цикла:

while ((с = getchar()) != EOF) putchar(c);

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

do {

с = getchar();

putchar(c); } while (с != EOF);

В этом случае в переменную будет записано мусорное значение, поскольку проверка производится уже после вызова putchar. Цикл do-while стоит применять только в тех случаях, когда тело цикла обязательно должно быть выполнено хотя бы один раз; некоторые примеры подобных ситуаций мы рассмотрим несколько позже.

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

int i, *iArray, nmemb;'

lArray = malloc(nmemb * sizeof(int)); for (i = 0; i <= nmemb; i++) iArray[i] = i;

Место в памяти выделяется для элементов в количестве nmemb — от iArray[0] до iArray[nmemb-1 ], но, поскольку в условии цикла проверка производится на "меньше или равно" (<=), цикл вылезет за границу массива и испортит новой записью то, что хранится за пределами выделенной памяти. К сожалению, ошибки подобного типа нередко можно обнаружить только после того, как данные уже разрушены.

В С и C++ есть также идиомы для выделения места под строки и для работы с ними, а код, который их не использует, зачастую таит в себе ошибку:

char *p, buf[256]; gets(buf);

р = malloc(strlen(buf)); strcpy(p, but);

Никогда не следует употреблять 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:

if (условие 1)

выражение 1 else if (условие 2) выражение 2

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

выражение п else выражение по умолчанию

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

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

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

Последовательность вложенных выражений if —. предвестник трудно читаемого кода, если не заведомых ошибок:

?if (argc == 3)

?if ((fin = fopen(argv[1], "г")) \= NULL)

?if ((tout = fopen(argv[2], >")) != NULL) {

?while ((c = getc(fin)) != EOF)

? putc(c, fout); fclose(fin); fclose(fout); } else

printf("He открыть выходной файл %s\n", argv[2]); else

printf("He открыть входной файл %s\n", argv[1]);

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

if (argc != 3)

printf ("Использование: ср входной_файл выходной_файл \п"); else if ((fin = fopen(argv[1], "г")) == NULL)

printf("He открыть входной файл %s\n", argv[1]); else if ((fout

= fopen(argv[2], "w")) == NULL) {

printf("He открыть выходной файл %s\n", argv[2]); fclose(fin); } else {

while ((c = getc(fin)) != EOF) putc(c, fout); fclose(fin);

fclose(fout);

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

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

switch (с) { case '-': sign = -1;

case '+': с = getchar(); ? case '.' ?

default:

}

Здесь используется замысловатая последовательность перескоков в выражениипереключателе, а все для того, чтобы избежать дублирования одной строки кода! В стандартной, идиоматической форме каждый вариант должен оканчиваться выходом (break), с редкими и обязательно откомментированными исключениями.

Традиционную структуру проще воспринимать, хотя она и получается несколько длиннее:

? switch (с) {

?case ' - ' : ? sign = -1;

?/* перескок вниз */

, ? case ' + ',: ? с = getchar();

?break;

?case ' . ' : ? break;

?default: ? if (lisdigit(c))

?return 0;

?break;

Некоторое удлинение кода с лихвой окупается увеличением ясности. В данной конкретной ситуации, однако, применение последовательности выражений else-if будет даже более понятным:

if (с == '-') { sign = -1;

с= getchar(); } else if (с == '+' ) {'

с= getchar(); } else if (с != '. ' && ! isdigit(c)) { return 0;

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

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

case '0' : case ' 1' : case '2' : break;

При такой записи комментарии не нужны.

Упражнение 1-7

Перепишите выражения C/C++ более понятным образом:

if (istty(stdin)) ; else if (istty(stdout)) ;

else if (istty(stderr)) ; else return(O); if (retval != SUCCESS) {

return (retval);

}

/* Все идет хорошо! */ return SUCCESS;

for (k = 0; k++ < 5; x += dx) scanf("%lf"! &dx);

Упражнение 1-8

Найдите ошибки в этом фрагменте кода на языке Java и исправьте их, переписав цикл в стандартной форме:

int count = 0; while (count < total) { count++;

if (this.getNaine(count) == nametable. userName()) { return (true);