Керниган Б., Пайк Р. Практика программирования

Подождите немного. Документ загружается.

Улучшите функцию:

int smaller(char *s, char *t) { if (strcmp(s, t) < 1)

return 1; else

return 0;

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

Прочитайте вслух следующее выражение:

if ((falloc(SMRHSHSCRTCH,

S._IFEXT|0644, MAXRODDHSH)) < 0)

Выражения

Итак, имена надо подбирать так, чтобы максимально облегчить жизнь читателю;

точно так же и выражения следует писать так, чтобы их смысл был предельно ясен.

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

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

выражения так, чтобы сделать их наиболее удобочитаемыми. Идея тривиальна,

но

очень полезна: совсем как мысль о том, что чем аккуратнее убран ваш рабочий стол,

тем проще на нем найти необходимую вещь. Правда, в отличие от рабочего стола в

вашей программе могут копаться и посторонние — и им тоже должно быть удобно.

Форматируйте код, подчеркивая его структуру. Форматирование кода логично

выбранными отступами

— самый простой способ добиться того, чтобы структура

программы стала самоочевидна. Приведенный фрагмент плохо отформатирован:

? for(n++;n<100;field[n++]='\(O');

? *i = \О'; return( '\n);

Проведя простейшее форматирование, мы несколько улучшим его:

? for (n++; n < 100; field[n++] = '\0')

? ;

? **i = \О'; ? return( '\n');

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

(приращение) счетчика в отдельный оператор, тогда цикл примет более

традиционный вид и, следовательно

, можно будет быстрее догадаться о его смысле.

for (n++; n < 100; n++)

field[n] = \О'; *i = \О';

return '\n';

Используйте естественную форму выражений. Записывайте выражения в том виде, в

котором вы произносили бы их вслух. Условные выражения, содержащие отрицания,

всегда трудно воспринять:

if (!(block_id < actblks) !(blocked >= unblocks))

Здесь каждая проверка используется с отрицанием, однако необходимости в этом

нет никакой. Достаточно изменить знаки сравнения, и можно обойтись без

отрицаний:

if ((blocked >= actblks) || (blockj.d < unblocks))

Теперь код читается вполне естественно.

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

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

даже тогда, когда с точки зрения грамматики в их применении нет необходимости.

Так, в предыдущем примере внутренние скобки не нужны, однако их применение как

минимум ничему не мешает. Бывалый программист мог бы

и опустить их, поскольку

операторы сравнения (< <= == ! = >= >) имеют более низкий приоритет, чем

логические операторы (&& и | |).

Все же, когда используются операторы с различным приоритетом, лучше применять

скобки. В языке С и ему подобных существует ряд проблем с последовательностью

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

логические операции имеют более

высокий приоритет, чем присваивание,

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

типа операций:

while ((с = getchar()) != EOF)

...

Побитовые операции & и | имеют более низкий приоритет, чем "обычные" операции

сравнения типа ==, так что, несмотря на, казалось бы, очевидный порядок

выполнения, выражение

if (x&MASK == BITS)

на самом деле выполнится как

? if (х & (MASK==BITS))

а это, очевидно, вовсе не

то, что подразумевал программист. Поскольку

используется комбинация операций сравнения и побитовых операций, скобки просто

необходимы:

if ((x&MASK) == BITS)

Даже если скобки в выражении не обязательны, они могут помочь сгруппировать

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

примере проверки високосности года по его номеру в использовании скобок нет

жесткой необходимости:

? lеар_уеаг = у % 4 == 0 && у % 100 ! = 0 | | у % 400 == 0;

но с ними фрагмент станет гораздо проще для понимания:

lеар_уеаг = ((у%4 == 0) && (у%100 != 0)) | (у%400 ==0);

Мы убрали здесь некоторые пробелы: группировка операций с самым высоким

приоритетом помогает читателю быстрее разобраться в структуре

программы.

Разбивайте сложные выражения. Языки С, C++ и Java имеют богатый и

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

одну конструкцию. Приведенное выражение весьма компактно, однако в нем

содержится слишком много операторов:

*х += (*xp=(2*k < (n-m) ? c [k+1] : d[k--]));

Если разбить это выражение на несколько, оно станет гораздо более

удобочитаемым:

if (2*k < n-m)

*хр = c[k+1j;

else

*xp = d[k--];

*x += *xp;

Будьте проще. Безудержная энергия

программистов иногда направляется на то,

чтобы написать наиболее краткий код или достичь результата самым хитрым и

красивым способом. Иногда, впрочем, эти таланты тратятся впустую: настоящая

задача в том, чтобы написать код попроще, а не похлеще. Вот, к примеру, что делает

это замысловатое выражение?

? subkey = subkey » (bitoff - ((bitoff » 3) « 3));

Самое внутреннее выражение сдвигает bitoff на три бита

вправо. Результат

сдвигается обратно влево, при этом три сдвинутых бита замещаются нулями. Затем

результат вычитается из первоначального значения, оставляя три младших бита

bitoff, которые используются для сдвига subkey вправо.

Таким образом, приведенная конструкция эквивалентна

subkey = subkey » (bitoff & 0x7);

Над первой версией приходится гадать некоторое время, чтобы понять, что там

происходит; со второй же все просто

и ясно. Опытные программисты записали бы ее

еще короче:

subkey »= bitoff & 0x7;

Некоторые конструкции кажутся специально созданными для того, чтобы сбить

читателя с толку. Например, применение оператора ? : может привести к появлению

абсолютно загадочного кода:

? child=(!LC&&!RC)?0:(!LC?RC:LC);

Согласитесь, что, только разобрав все возможные варианты сравнений, можно

догадаться, что же делает этот фрагмент. Приведенная ниже конструкция длиннее,

но значительно проще, потому что возможные варианты видны сразу:

f (LC == 0 && RC == 0)

child = 0; else if (LC == 0)

child = RC; else

child = LC;

Операция ? : хороша только для коротких и простых выражений-, где она может

заменить четыре строки if-else одной, как в следующем примере:

max = (а > b) ? а : b;

или даже в таком случае:

printf("The list has %d item%s\n", n, n==1 ? ""

: "s");

однако подобная замена все же не является распространенной.

Ясность и краткость — не одно и то же. Часто более ясный код

будет и более

коротким (как в примере со сдвигом битов), однако он может быть и, наоборот, более

длинным (как в примере с if-else). Главным критерием выбора должна служить

простота восприятия.

Будьте осторожны с побочными эффектами. Операции типа ++ имеют побочные

эффекты: они не только возвращают значение, но еще и изменяют операнд. Эти

побочные

эффекты иногда могут быть весьма удобны, но они же могут вызвать

трудности из-за того, что получение значения и обновление переменной могут

происходить не тогда, когда ожидается. В С и C++ порядок выполнения этих

побочных эффектов вообще не определен, поэтому нижеприведенное

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

? str[i++] = str[i++] = ' ';

Смысл выражения

— записать пробел в следующие две позиции строки str. Однако в

зависимости от того, когда будет обновляться i, позиция в st r может быть

пропущена, и в результате переменная 1 будет увеличена только на 1. Разбейте

выражение на два:

str[i++] = ' ';

str[i++] =''.-"';

Даже если в вы ражении содержится только один инкремент, результат может быть

неоднозначным:

? array[i++] = i;

Если изначально i имеет значение 3, то элемент массива может принять значение 3

либо 4.

Побочные эффекты есть не только у инкремента и декремента; ввод-вывод — еще

один потенциальный источник возникновения закулисных действий. В следующем

примере осуществляется попытка прочитать два взаимосвязанных числа из

стандартного ввода:

scanf ("' &yr, &profit[yr]);

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

а другая использует ее.

Значение prof it[yr] будет правильным только в том случае, если новое значение уг

будет таким же, как и старое. Вы, наверное, думаете, что все дело в порядке

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

аргументы scanf вычисляются до того, как эта операция вызывается на выполнение,

так

что &profit[yr] всегда будет вычисляться с использованием старого значения у г.

Проблемы подобного рода могут возникнуть в любом языке программирования. Для

исправления достаточно опять же разбить выражение на две части:

scanf("%d", &yr);

scanf("%d", &profit[yr]);

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

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

Улучшите каждый из приведенных фрагментов:

if ( !(с == 'у' || с == 'V) ) return;

length = (length < BUFSIZE) ? length : BUFSIZE; ,

flag = flag ? 0 : 1;

quote = (*line == "") ?* 1 : 0;

if (val & 1)

t else

bit=0

Упражнение

1-5

Найдите ошибку в приведенном фрагменте:

? i'nt read(int *ip) { ? scanf("%d", ip);

? return *ip;

? }

? insert(&graph[vert], read(.&val), read(&ch));

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

Перечислите все возможные варианты, которые выдаст приведенное выражение в

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

? 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 (;;)

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

while (1)

........

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

Использование отступов также должно быть стандартным, можно сказать —

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

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

отдельных выражения, а не

как единый заголовок цикла:

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)