WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 | 3 | 4 | 5 |
-- [ Страница 1 ] --

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

Практика программирования Авторы:

Б. Керниган, Р. Пайк.

Серия:

Библиотека программиста Год издания:

2001 Учебник по технологии программирования Оглавление Введение Стиль Алгоритмы и структуры данных Проектирование и реализация Интерфейсы Отладка Тестирование Производительность Переносимость Нотация Эпилог Приложение: свод правил Введение Приходилось ли вам когда-нибудь:

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

• использовать слишком сложную структуру данных?

• при тестировании программы пропустить очевидную проблему?

• тратить день на то, чтобы обнаружить ошибку, которую можно было бы найти • за пять минут?

сталкиваться с тем, что программа должна работать в три раза быстрее и • использовать меньше памяти?

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

пытаться внести изменения в чужую программу?

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

• Ну и как — понравилось?

С программистами такое происходит все время. Однако справиться с подобными проблемами часто гораздо труднее, чем хотелось бы, поскольку такие темы, как тестирование, отладка, переносимость, производительность, альтернативы проектирования и стиль, темы, относящиеся к практике программирования, как правило, оказываются вне сферы внимания информатики и учебных курсов по программированию. Большинство программистов изучают их сами по себе, — в основном, на собственном опыте, а некоторые не изучают вообще.

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

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

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

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

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

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

Единственное, что вам необходимо, — это иметь некоторый опыт в программировании, желательно на С, C++ или Java. Естественно, чем больше ваш опыт, тем проще вам будет понять и применить наши советы, ничто не сможет сделать эксперта из новичка за 21 день.

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

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

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

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

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

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

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

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

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

Тестирование — это попытка дать разумное обоснование работоспособности программы. Глава 6 посвящена систематическому тестированию программ как вручную, так и с помощью'компьютера. Тесты на граничные условия проверяют потенциальные слабые места программ. Механизация и специальная тестовая оснастка позволяют осуществлять комплексное тестирование с достаточно скромными затратами. Особым типом тестов являются стрессовые тесты, они проверяют устойчивость программ.

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

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

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

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

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

Разговор о программировании, естественно, не может обойтись без демонстрации изрядного количества кода. Большинство примеров написано специально для этой книги, но некоторые небольшие фрагменты были взяты из ранее написанных программ. Мы очень старались писать свой код хорошо;

все примеры тестировались на нескольких системах. Дополнительную информацию можно получить на web сайте, посвященном этой книге (в английском варианте — The Practice of Programming):

http://tpop.awl.com Большинство программ написано на С;

есть примеры на C++ и Java;

предпринят и краткий экскурс в языки скриптов. На нижнем уровне С и C++ практически идентичны, так что наши программы на С являются вполне приемлемыми программами на C++. Языки C++ и Java— прямые наследники С, они унаследовали изрядную долю синтаксиса, эффективности и выразительности С, добавив более широкие системы типов и библиотек. Мы сами в повседневной работе широко используем и эти три языка, и множество других. Выбор языка зависит от задачи:

операционные системы лучше всего писать на эффективном и не давящем языке вроде С или C++;

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

для пользовательских интерфейсов хорошо подходят Visual Basic, Tcl/Tk и Java.

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

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

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

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

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

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

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

Стиль Имена • Выражения • Стилевое единство и идиомы • Макрофункции • Загадочные числа • Комментарии • Стоит ли так беспокоиться?

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

Вильям Странк, Элвин Б. Уайт. Элементы стиля Приводимый фрагмент кода взят из большой программы, написанной много лет назад:

if ( (country == SING) || (country == BRNI) || (country == POL) |[ (country == ITALY) ) { /* * если страна - Сингапур, Бруней или Польша, * то временем ответа является текущее время, * а не время, передаваемое в параметре.

* Переустанавливается время ответа * и задается день недели. */...

Этот фрагмент тщательно написан, форматирован и комментирован, а программа, из которой он взят, работает предельно корректно;

программисты, написавшие ее, по праву гордятся своим творением. Однако для постороннего глаза этот фрагмент все же представляется странноватым. По какому принципу объединены Сингапур, Бруней, Польша и Италия? И почему Италия не упомянута в комментариях? Код и комментарий не совпадают, так что один из них неверен. Не исключено, что неверны и оба. Правда, код все же исполнялся и тестировался, так что, скорее всего, он верен, а комментарий просто забыли обновить вместе с кодом. Комментарий не объясняет, что общего у перечисленных в нем стран, хотя эта информация будет просто необходима, если вам придется заниматься поддержкой этого кода.

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

Начнем мы с непривычного — с обсуждения стиля в программировании. Чем лучше у вас стиль, тем проще читать ваши программы вам самим и другим программистам;

хороший стиль просто необходим для хорошего программиста. Мы начинаем со стиля, чтобы в дальнейшем вы обращали на него внимание во всех примерах.

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

Принципы хорошего стиля программирования состоят вовсе не в наборе каких-то обязательных правил, а в здравом смысле, исходящем из опыта. Код должен быть прост и понятен: очевидная логика, естественные выражения, использование соглашений, принятых в языке разработки, осмысленные имена, аккуратное форматирование, развернутые комментарии, а также отсутствие хитрых трюков и необычных конструкций. Логичность и связность необходимы, потому что другим будет проще читать код, написанный вами, а вам, соответственно, — их код, если все будут использовать один и тот же стиль. Детали могут быть продиктованы местными соглашениями, требованиями менеджмента или самой программой, но даже если это не так, то лучше всего подчиняться наиболее распространенным соглашениям. Мы в своем повествовании будем придерживаться стиля, использованного в книге "Язык программирования С" с некоторыми поправками для C+ + и Java.

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

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

Некоторые куски будут несколько укорочены для большей выразительности, но не искажены. После "плохих" примеров мы будем приводить варианты, показывающие, как можно их улучшить. Так как все примеры взяты из реальных программ, со многими из РГИХ связано сразу несколько проблем. Обсуждение всех недостатков сразу уводило бы нас слишком далеко, так что некоторые примеры хорошего стиля будут по-прежнему таить в себе другие, неотмечаемые погрешности.

Для того чтобы вы могли без труда отличить хорошие примеры от плохих, мы будем начинать строки сомнительного кода со знака вопроса, как, например, в этом фрагменте (помните — все фрагменты взяты из реальных программ):

? «define ONE ? «define TEN ? «define TWENTY Что может быть спорным в этих макроопределениях? А вы представьте себе изменения, которые необходимо будет внести в программу, если массив из TWENTY (двадцати) элементов понадобится увеличить. Нужно по меньшей мере заменить все имена на более осмысленные, указывающие на роль данного значения в программе:

# define INPUT_MODE # «define INPUT_BUFSIZE # «define OUTPUT_BUFSIZE Имена Что в имени? Имя переменной или функции помечает объект и содержит некоторую информацию о его назначении. Имя должно быть информативным, лаконичным, запоминающимся и, по возможности, произносимым. Многое становится ясным из контекста и области видимости переменной: чем больше область видимости, тем более информативным должно быть имя.

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

int npending = 0;

// текущая длина очереди ввода Глобальные функции, классы и структуры также должны иметь осмысленные имена, поясняющие их роль в программе.

Для локальных переменных, наоборот, лучше подходят короткие имена;

для использования внутри функции вполне сойдет просто п, неплохо будет смотреться npoints, а вот numberO.f Points будет явным перебором.

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

Сравните for (theElementlndex = 0;

theElementlndex < numberOfElements;

?

theElementIndex-н-) ? elementArrayftheElementlndex] = theElementlndex;

и for (i = 0;

i < nelems;

i++) elem[i] = i;

Бывает, что программисты используют длинные имена независимо от контекста. Это ошибка: ясность часто достигается краткостью.

Существует множество соглашений и местных традиций именования. К наиболее распространенным правилам относятся использование для указателей имен, начинающихся или заканчивающихся на р (от pointer, указатель), например nodep, а также заглавных букв в начале имен Глобальных переменных и всех заглавных — в именах КОНСТАНТ. Некоторые программистские фирмы придерживаются более радикальных правил, таких как отображение в имени переменной информации об ее типе и способе использования. Например, реп будет означать указатель на символьный тип (pointer to char), a st rFrom и strTo — строки для ввода и вывода, соответственно. Что же касается собственно напи-. сания имен, то.использование npending, numPending или num_pending зависит от личных пристрастий, и принципиальной разницы нет. Главное — соблюдать основные смысловые соглашения;

все, что не выходит за их рамки, уже не так важно.

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

Пространства имен (namespaces) в C++ и пакеты (packages) в Java позволяют разграничивать области видимости переменных и тем самым помогают сохранить ясность кода без использования чрезмерно длинных имен.

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

Вот пример на языке Java, где имена членов класса не только слишком длинны, но и абсолютно непоследовательны:

? class UserQueue {.

? int noOfltemsInQ, f rontOfTheQueue, queueCapacity;

? public int noOfllsersInQueueO {....} Слово "queue" (очередь) используется в названиях как Q, Queue и queue. Однако, поскольку доступ к очереди может быть получен только через переменную типа UserQueue, в именах членов класса упоминание слова "queue" вообще не нужно — все будет понятно из контекста. Так, двойное упоминание очереди ? queue. queueCapacity избыточно.Класс лучше описать так:

class UserQueue { int nitems, front, capacity;

public- int nusers( ) {... } поскольку выражения вроде queue.capacity+++;

n=queue.nusers() вполне ясны и понятны. Последняя версия тоже еще не идеальна: термины "items" и "users" обозначают одно и то же, так что для одного понятия следовало бы использовать только один термин.

Используйте активные имена для функций. Имя функции должно базироваться на активном глаголе (в действительном залоге), за которым может следовать существительное:

now = date.getTime();

putchar( "\n-);

Функции, которые возвращают логическое значение (истина или ложь — t rue или false), нужно называть так, чтобы их смысл не вызывал сомнений. Так, из вызова ? if (checkoctal(c))...

непонятно, когда будет возвращаться t rue, а когда false, а вот вызов if (isoctal(c))...

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

Будьте точны. Как мы уже решили, имя не только обозначает объект, но и предоставляет читателю некоторую информацию о нем. Неверно подобранное имя может стать причиной совершенно таинственных ошибок.

Один из нас написал и не один год распространял макрос, называемый isoctal, имеющий некорректную реализацию:

«define isoctal(c) ((с) >= '0' && (с) <= '8')?

вместо правильного «define isoctal(c) ((c)>= '0' && (с) <= '7') В этом случае имя было правильным, а реализация ошибочной;

правильное имя облегчило раскрытие ошибки.

В следующем примере имя и код находятся в полнейшем противоречии:

? public boolean inTable(Object obj) { ? int j = this.getlndex(ob]);

? return (j == nTable);

?} Функция getlndex возвращает значение от 0 до nTable-1 в случае, если объект найден, и nTable, если объект не найден. Таким образом, возвращаемое логическое значение будет прямо противоположно тому, что подразумевается в имени функции.

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

Упражнение 1- Составьте комментарий, объясняющий принцип выбора имен и значений в следующем примере:

? «define TRUE О ? «define FALSE ? if ((ch = getcharO) == EOF) ? not_eof = FALSE;

Упражнение 1- Улучшите функцию:

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

else return 0;

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

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, то элемент массива может принять значение либо 4.

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

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

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

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

Значение prof it[yr] будет правильным только в том случае, если новое значение уг будет таким же, как и старое. Вы, наверное, думаете, что все дело в порядке вычисления аргументов, однако в действительности проблема здесь в том, что все аргументы scanf вычисляются до того, как эта операция вызывается на выполнение, так что &profit[yr] всегда будет вычисляться с использованием старого значения у г.

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

scanf("%d", &yr);

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

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

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

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

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

, flag = flag ? 0 : 1;

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

if (val & 1) t else bit= Упражнение 1- Найдите ошибку в приведенном фрагменте:

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

? return *ip;

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

Упражнение 1- Перечислите все возможные варианты, которые выдаст приведенное выражение в зависимости от порядка вычислений:

? n= ? 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) выражение 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- Перепишите выражения 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- Найдите ошибки в этом фрагменте кода на языке Java и исправьте их, переписав цикл в стандартной форме:

int count = 0;

while (count < total) { count++;

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

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

операции ввода-вывода, такие как getchar, и проверки символов вроде isdigit — это, так сказать, официально утвержденные примеры. Причина — в производительности:

у макросов нет "накладных расходов", которые свойственны вызовам функций.

На самом деле этот аргумент был не слишком убедительным уже в те времена, когда С только появился, — в эпоху медленных машин и "дорогих" вызовов функций;

теперь же он просто нелеп. Для современных машин и компиляторов недостатки макрофункций перевешивают их достоинства.

Избегайте макрофункций. В C++ встраиваемые (inline) функции делают использование макрофункций ненужным;

в Java макросов вообще не существует. В С они больше проблем создают, чем решают.

Одна из наиболее серьезных проблем, связанных с макрофункциями: параметр, который появляется в определении более одного раза, может быть вычислен также более одного раза;

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

? «define isupper(c) ((с) >= 'A' && (с) <= 'Z') Обратите внимание на то, что параметр с дважды появляется в теле макроса. Если же наш макрос is up ре г вызывается в контексте вроде такого:

? while (isupper(c = getchar())) ?

то каждый раз, когда вводимый символ будет больше или равен А, он будет пропущен, и для сравнения с Z будет считан еще один символ. Стандарт С написан таким образом, чтобы функции, аналогичные isupper, можно было реализовать как макросы, но только если они гарантируют, что аргумент будет вычисляться лишь единожды, так что приведенная выше реализация не отвечает требованиям стандарта.

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

кроме того, функции с побочными эффектами, типа getcha г, лучше не применять внутри составных выражений. Если разбить условие цикла на два выражения, то оно будет более понятно для читателя и, кроме того, даст возможность четко отследить конец файла:

while ((с = getcharO) != EOF && isupper(c)) Иногда многократные вычисления не несут в себе прямых ошибок, но снижают производительность. Рассмотрим такой пример:

? «define ROUND_TO_INT(x) ((int.) ((х) + (( (х)>0)?0. 5:

-0. 5))) ?

? size = ROUND_TO_INT(sqrt(dx*dx + dy*dy));

Вычисление квадратного корня будет производиться в два раза чаще, чем требуется (он передается как аргумент, который дважды участвует в вычислении). Даже при задании простого аргумента сложное выражение вроде ROUND_TOINT преобразуется во множество машинных команд, которые лучше хранить в одной функции, вызываемой при необходимости. Обращения к макросу увеличивают размер скомпилированной программы. (Встраиваемые (inline) функции в C++ имеют тот же недостаток.) Заключайте тело макроса и аргументы в скобки. Если вы все же решили использовать макрофункции, будьте с ними осторожны. Макрос работает за счет простой подстановки текста: параметры в описании заменяются аргументами вызова, и результат (текст!) замещает собой текст вызова. В этом состоит важное отличие макросов от функций, делающее макросы столь ненадежными. Так, выражение 1 / square(x) будет работать отлично, если square — это функция, однако если это макрос вроде следующего:

? «define square(x) (x) * (х) то выражение будет преобразовано в ошибочное:

? 1 / (х) * (х) Этот макрос надо переписать так:

«define square(x) ((x) * (х)) Скобки здесь необходимы, однако даже грамотная расстановка скобок не спасет макрос от его главной беды — многократного вычисления аргументов. Если операция настолько сложна или настолько часто повторяется, что ее стоит вынести в отдельный блок, используйте для этого функцию.

В C++ встраиваемые (inline) функции позволяют избежать синтаксических проблем, сохраняя при этом высокую производительность, присущую макросам. Они хорошо подходят для коротких функций, которые получают или устанавливают только одно значение.

Упражнение 1- Определите все проблемы, связанные с приведенным описанием макроса:

? «define ISDIGIT(c) ((с >= '0') && (с <= '9')) ?

1: О Загадочные числа Загадочные числа — это константы, размеры массивов, позиции символов и другие числовые значения, появляющиеся в программе непосредственно, как "буквальные константы".

Давайте имена загадочным числам. В принципе нужно считать, что любое встречающееся в программе число, отличное от 0 и 1, является загадочным и должно получить собственное имя. Просто "сырые" числа в тексте программы не дают представления об их происхождении и назначении, затрудняя понимание и изменение программы. Вот отрывок из программы, которая печатает гистограмму частот букв на терминале с разрешением 24 X 80. Этот отрывок неоправданно запутан из-за целого сонма непонятных чисел:

fac = lim / 20;

/* установка масштаба */ if (fac < 1) fac = 1;

/* генерация гистограммы */ for (i = 0, col = 0;

i < 27;

i++, j++) { col += 3;

k = 21 - (let[i] / fac);

star = (let[i] == 0) ? ' ' : '*';

for (j = k;

j < 22;

j++) draw(j, col, star);

} draw(23, 2, ' ');

/* разметка оси х */ Наряду с другими в коде присутствуют числа 20, 21, 22, 23 и 27. Они как-то тесно связаны... или нет? На самом деле есть только три критических числа, существенных для программы: 24 — число строк экрана;

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

Присвоив имена числам, имеющим принципиальное значение, мы облегчим понимание кода. Например, станет понятно, что число 3 берется из арифметического выражения (80-1)/26, а массив let должен иметь 26 элементов, а не 27 (иначе возможна ошибка его переполнения на единицу — из-за того, что экранные координаты индексируются, начиная с 1). Сделав еще пару усовершенствований, мы придем к следующему результату:

enum { MINROW =1, /* верхняя граница */ MINCOL =1, /* левая граница */ MAXROW = 24, /* нижняя граница (<=) */ MAXCOL = 80, /* правая граница (<=) */ LABELROW =1, /* позиция подписей оси */ NLET = 26, f /* количество букв алфавита */ HEIGHT = MAXROW - 4, /* высота столбиков */• WIDTH = (MAXCOL-1)/NLET /* ширина столбиков */ };

fac = (lim + HEIGHT-1) / HEIGHT;

/* установка масштаба */ if (fac < 1) fac = 1;

for (i = 0;

i < NLET;

i++) { /* генерация гистограммы */ if (let[i] == 0) continue;

for (j = HEIGHT - let[i]/fac;

j < HEIGHT;

j++) draw(j+1 + LABELROW, (i+1)*WIDTH, '*'•);

} draw(MAXROW-1, MINCOL+1, ' ');

/* разметка оси х */ for (i = 'A';

i <= 'Z';

i++) printf("%c ", i);

Теперь стало гораздо понятнее, что же делает основной цикл: в нем используется стандартный идиоматический цикл от 0 до NLET-1, то есть по всем элементам данных. Вызовы функции d raw также стали более понятны — названия вроде MAXROW и MINCOL дают четкое представление об аргументе. Главное же — программу теперь можно без труда адаптировать к другому разрешению экрана или другому алфавиту: с чисел и с кода снята завеса таинственности.

Определяйте числа как константы, а не как макросы. Программисты, пишущие на С, традиционно использовали для определения загадочных чисел директиву #def те.

Однако препроцессор С — мощный, но несколько туповатый инструмент, а макросы — вообще довольно опасная вещь, поскольку они изменяют лексическую структуру программы. Пусть лучше язык делает свойственную ему работу. В С и C++ целые (integer) константы можно определять с помощью выражения en urn (которое мы и использовали в предыдущем примере). В C++ любые константы можно определять с помощью ключевого слова const:

const int MAXROW = 24, MAXCOL = 80;

В Java для этого служит слово final:

static final int MAXROW = 24, MAXCOL = 80;

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

Используйте символьные, а не целые константы. Для проверки свойств символов должны использоваться функции из или их эквиваленты. Если проверку организовать так:

? if (с >= 65 && с <= 90) ?....

то ее результат будет всецело зависеть от представления символов на конкретной машине. Лучше использовать if (с >= 'А' с <= 'Z') ?...

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

if (isupper(c)) в С и C++ или if (Character. isllpperCase(c)) в Java.

Сходный вопрос — использование в программе числа 0. Оно используется очень часто и в различных контекстах. Компилятор преобразует этр число в соответствующий тип, однако читателю гораздо проще понять роль каждого конкретного 0, если тип этого числа каждый раз обозначен явным образом. Так, например, стоит использовать (void * )0 или NULL для обозначения нулевого указателя в С, а ' \0' вместо просто 0 — для обозначения нулевого байта в конце строки. Другими словами, не пишите ? str = 0;

? nameti] = 0;

? х = 0;

а пишите str = NULL;

name[i] = '\0';

х = 0.0;

Мы рекомендуем использовать различные явные константы, оставив О для простого целого нуля, — такие константы обозначат цель использования данного значения.

Надо отметить, правда, что в C++ для обозначения нулевого указателя принято использовать все же 0, а не NULL. Лучше всего проблема решена в Java — там ключевое слово null определено как ссылка на объект, которая ни к чему не относится.

Используйте средства языка для определения размера объекта. Не используйте явно заданного размера ни для каких типов данных — так, например, используйте sizeof (int) вместо прямого указания числа 2,4 и т.п. По сходным причинам лучше использовать sizeof(array[OJ) вместо sizeof (int) — меньше придется исправлять при изменении типа массива.

Использование оператора sizeof избавит вас от необходимости выдумывать имена для чисел, обозначающих размер массива. Например, если написать char buf[1024];

fgets(buf, sizeof(buf), stdin);

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

У массивов в Java есть поле length, которое содержит количество элементов:

char buf[] = new char[1024];

for (int 1=0;

i < but.length;

i++).....

В С и C++ нет эквивалента этому полю, но для массива (не указателя), описание которого является видимым, количество элементов можно вычислить с помощью следующего макроса:

«define NELEMS(array) (sizeof(array) / sizeof(array[0])) double dbuf[100];

for (i = 0;

i < NELEMS(dbuf);

i++) Здесь опять-таки размер массива задается лишь в одном месте, и при его изменении весь остальной код менять не придется.

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

Упражнение 1- Как бы вы переписали приведенные определения, чтобы уменьшить число потенциальных ошибок?

?define FT2METER ?define METER2FT ?define MI2FT ?define MI2KM ?define SQMI2SQKM 2. Комментарии Комментарии должны помогать читать программу. Они не помогут, повторяя то, что и так понятно из кода или противореча коду или отвлекая читателя от сути типографскими ухищрениями. Лучший комментарий помогает понимать программу, кратко отмечая наиболее значимые детали или предоставляя укрупненную картину происходящего.

Не пишите об очевидном. Комментарии не должны содержать самоочевидной информации типа того, что оператор i++ увеличивает i. Ниже приведены некоторые из наших чемпионов бессмысленности:

/* по умолчанию */ default: break;

/* возвращаем SUCCESS */ return SUCCESS;

? zerocount++;

/* Увеличиваем счетчик нулевых элементов */ ? /* Устанавливаем "total" в "number_received" */ ? node->total = node->number_received;

Все эти комментарии надо удалить, они лишь мешают.

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

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

while ((с = getchar()) != EOF && isspace(c)) ;

/* пропуск пробелов */ /* конец файла */ if (с == EOF) type = endoffile;

else if (с == ' (') type = leftparen;

else if (c == ')') type = rightparen;

else if (c == ';

') type = semicolon;

else if (is_op(c)) type = operator;

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

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

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

struct State { /* префикс + список суффиксов */ char *pref[NPREF];

/* префиксы */ Suffix *suf;

/* список суффиксов */ State *next;

/* следующий в хэш-таблице */ ):

Иногда код действительно сложен, возможно, из-за сложного алгоритма или замысловатых структур данных. В таком случае читателю может помочь комментарий, указывающий на источник, в котором описан данный алгоритм или структура. В него можно также включить пояснения, касающиеся того, почему были приняты те или иные конкретные решения. Ниже приведен комментарий, предваряющий весьма эффективную реализацию обратного дискретного косинус преобразования (discrete cosine transform - DCT), используемого в декодере изображений в формате JPEG:

/* * idct: масштабированная целочисленная реализация * обратного двумерного (8x8) дискретного * косинус-преобразования (ОСТ).

* Алгоритм Чен-Ванга (Chen-Wang) * (IEEE ASSP-32, с. 803-816, август 1984) * * 32-битовая целочисленная арифметика 8-битовые коэффициенты * 11 умножений, 29 сложений на одно DCT * * Коэффициенты увеличены до 12 битов для совместимости * с IEEE 1180- */ static void idct(int b[8*8]) В этом содержательном комментарии имеется ссылка на описание алгоритма, кратко представлены используемые данные, обозначена производительность алгоритма и показано, когда и для чего была произведена модификация кода.

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

/* Если result = 0, то было найдено совпадение, поэтому возвращаем true (не 0). В противном случае result не равен нулю, поэтому возвращаем false.(ноль).

*/ tfifdef DEBUG printf("*** isword возвращает ! result = %d\n", ! result);

fflush(stdout);

tfendif return(! result);

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

#ififdef DEBUG printf("*** isword возвращает matchfound = %d\n", matchfound);

fflush(stdout);

#endif return matchfound;

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

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

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

time(&now);

strcpy(date, ctime(&now));

/* избавляемся от замыкающего символа перевода строки, скопированного из ctime */ 1 =.0;

while(date[i] >= ' ') i++;

date[i] - 0;

Первое, что надо сделать, это переписать код в более привычном идиоматическом виде:

time(&now);

strcpy(date, ctime(&now));

/* избавляемся от замыкающего символа перевода строки, скопированного из ctime */ for (i = 0;

date[i] != Дп';

i++) date[i] = '\0';

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

time(&now);

strcpy(date, ctime(&now));

/* ctimeQ помещает символ перевода строки в конец возвращаемой строки;

его надо удалить'*/ date[strlen(date)-1] =' \О';

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

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

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

? int strcmp(char *s1, char *s2) ? /* процедура сравнения строк возвращает -1, если */ /* s1 стоит выше s2 в списке по возрастанию, */ /* 0, если строки равны, и 1, если s1 ниже s2 */ ?{ ? while(*s1==*s2) { ? if(*s1=='\0') return(O);

? S1++;

? s2++;

?} if(*s1>*s2) return(l);

? return(-1);

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

если во фрагменте реализуется стандартная функция, комментарий должен лишь обобщать сведения о ее поведении и сообщать, откуда взялось ее определение, вот и все:

/* strcmp: возвращает < 0 если s1 0 если s1>s и 0 если s1=s2 */ /* ANSI С, раздел 4.11,4.2 */, int strcmp(const char *s1, const char *s2) {....

} Студентам внушают, что комментировать надо все подряд;

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

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

Упражнение 1- Прокомментируйте эти комментарии.

?void diet::insert(string& w) ?// возвращает 1, если w в словаре, в противном случае - О ?if (п > МАХ || п % 2 > 0) // проверка на четность ?// Пишем сообщение ?// Увеличить счетчик строк для каждой написанной строки ? void writejnessage() ? // увеличить счетчик строк ? line_number =,line_number + 1;

? fprintf(fout, "%d %s\n%d %s\n%d %s\rv", ? line^number, HEADER, 7 line_number + 1, BODY, ? line_number + 2, TRAILER);

? // увеличить счетчик строк ? line_number = line_number + 2;

7} Стоит ли так беспокоиться?

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

Однако стоит ли так беспокоиться о стиле? Кому какая разница, как программа выглядит изнутри, если она работает? Не слишком ли много времени придется тратить на ее "причесывание"? Не слишком ли расплывчаты рекомендуемые правила?

Ответ на эти вопросы состоит в следующем: хорошо и красиво написанный код проще читать и воспринимать;

в нем, без сомнения, содержится меньше ошибок, и он почти наверняка будет короче, чем код, бездумно скомпонованный и оставленный без улучшений. Когда программа пишется в спешке, когда и так трудно успеть к установленным срокам, кажется вполне естественным не обращать внимания на стиль, оставив заботы о нем на потом. Однако подобное решение может оказаться весьма накладным. Некоторые примеры из этой главы уже дали вам представление о том, что может случиться, если пренебрегать хорошим стилем. Небрежно оформленный код — плохой код, и не только потому, что выглядит он некрасиво и читать его трудно;

как правило, в таком коде содержатся и ошибки.

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

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

Дополнительная литература Как мы уже заявляли в начале главы, писать хороший код и просто хорошо писать по-английски — достаточно схожие понятия. "Элементы стиля" В. Странка и Э. Б.

Уайта (W. Strunk, E. В. White. The Elements of Style. Allyn & Bacon) — самый хороший из небольших учебников письменного английского.

Эта глава во многом взята из книги Брайана Кернигана и П. Дж. Пла-угера "Элементы стиля программирования" (Brian Kernighan, P. J. Plau-ger. The Elements of Programming Style. McGraw-Hill, 1978). "Создание надежного кода" Стива Магьюира (Steve Maguire. Writing Solid Code. Microsoft Press, 1993) — идеальный источник советов по программированию. Кроме того, интересное обсуждение стиля имеется в книгах Мак-Коннелла "Все о коде" (Steve McConnell. Code Complete. Microsoft Press, 1993) и Питера ван дер Линдена "Профессиональное программирование на С:

Секреты С" (Peter van der Linden. Expert С Programming: Deep С Secrets. Prentice Hall, 1994).

Алгоритмы и структуры данных Поиск • Сортировка • Библиотеки • Быстрая сортировка на языке Java • "О большое" • Динамически расширяемые массивы • Списки • Деревья • Хэш-таблицы • Заключение • Дополнительная литература • В конце концов, только знание инструментов и технологий обеспечит правильное решение поставленной задачи, и только определенный уровень опыта обеспечит устойчиво профессиональные результаты.

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

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

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

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

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

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

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

char *flab[] = { "actually", "just", "quite", "really", NULL };

Функция поиска должна знать, сколько в массиве элементов. Один из способов сообщить ей это — передать длину массива в виде аргумента;

второй способ, использованный здесь, — поместить в конце массива элемент-маркер NULL:

/* lookup: последовательный поиск слова в массиве */ int lookup(char *word, char *array[]) { int i;

for (i = 0;

array[i] != NULL;

i++) if (strcmp(word, array[i]) == 0) return i;

return -1;

} В С и C++ для передачи в качестве параметра массив строк можно описать как char *array[] или char **array. Эти две формы эквивалентны, но в первой сразу видно, как будет использоваться параметр.

Предлагаемый поисковый алгоритм называется последовательным, поиском, потому что он просматривает по очереди все элементы, сравнивая их с искомым. Когда данных немного, последовательный поиск работает достаточно быстро. Есть стандартные библиотечные функции, которые выполняют последовательный поиск для определенных типов данных. Например, в языках С и C++ функции st rch г и st rst r ищут первое вхождение заданного символа или подстроки в строку, в Java у класса String есть метод indexOf, а обобщенные функции поиска в C++ find применимы к большинству типов данных. Если такая функция существует для нужного вам типа данных, то используйте ее.

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

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

Вот пример массива более реалистичного размера из программы, выполняющей синтаксический разбор текста, написанного на HTML, где определены имена более чем сотни отдельных символов:

typedef struct Nameval Nameval;

struct Nameval { char *name;

int value;

/* символы HTML, например AElig - лигатура1 А и Е.

*/ /* значения в кодировке Unicode/18010646 */ Nameval htmlchars[] = { "AElig", ОхООсб, /* лигатура А и Е "Aacute", OxOOd, /* А с акцентом "Acirc", OxOOc2, /* А с кружочком /*...*/ "zeta", ОхОЗЬб, /* греческая дзета */ };

Для объемистого массива вроде этого более эффективно было бы использовать двоичный поиск. Алгоритм двоичного поиска является систематизированной версией поиска слова в словаре. Проверяем средний элемент. Если это значение больше, чем нужное, то ищем далее в первой части;

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

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

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

printf("Ta6лица HTML содержит %d слов\n", NELEMS(htmlchars));

Функция двоичного поиска для этой таблицы могла бы выглядеть так:

/* lookup: двоичный поиск имени name в таблице tab;

возвращается индекс */ int lookup(char *name, Nameval tab[], int ntab) { int low, high, mid, cmp;

low = 0;

high = ntab - 1;

while (low <= high) { mid = (low + high) / 2;

cmp = strcmp(name, tab[mid].name);

if (cmp < 0) high = mid - 1;

else if (cmp > 0) low = mid + 1:

else /* совпадение найдено */ return mid;

} return -1;

/* совпадений нет */ Объединяя все это вместе, мы можем написать:

half = lookup("frac12", htmlchars, NElEMS(htmlchars));

для определения индекса, под которым символ 1/2 (одна вторая) стоит в массиве htmlchars.

Двоичный поиск отбрасывает за каждый шаг половину данных, поэтому количество шагов пропорционально тому, сколько раз мы можем поделить п на 2, пока у нас не останется один элемент. Без учета округления это число равно Iog2 п. Если у нас в массиве 100"0 элементов, то линейный поиск займет до 1000 шагов, в то время как двоичный — только около 10;

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

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

Если набор данных известен заранее, то он может быть отсортирован при написании программы и проинициализирован во время компиляции. Иначе придется сортировать его во время выполнения программы.

Один из самых лучших алгоритмов сортировки — быстрая сортировка (quicksort), которая была придумана в 1960 году Чарльзом Хоаром (С. A. R. Ноаге). Быстрая сортировка — замечательный пример того, как можно избежать лишних вычислений.

Она работает при помощи разделения массива на большие и маленькие элементы:

выбрать один элемент массива ("разделитель"):

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

"маленькие", то есть меньшие, чем разделитель, "большие", то есть большие или равные разделителю, рекурсивно отсортировать обе группы.

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

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

Алгоритм быстрой сортировки практичен и эффективен;

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

Наша функция quicksort сортирует массив целых чисел:

/* quicksort: сортирует v[0]..v[n-1] по возрастанию */ void quicksоrtClrrt v[], int n) >{ int i, last;

if (n <= 1) /* ничего не делать */ return;

swap(v, 0, rand() % n);

/* поместить разделитель в v[0] */ last = 0;

for (i = 1;

i < n;

i++) /* разделить */ if (v[i] < v[0]) swap(v, ++last, i);

swap(v, 0, last);

/* сохранить разделитель */ quicksort(v, last);

/* рекурсивно отсортировать */ quicksort(v+last+1, n-last-1);

/* каждую часть */ } Операция swap, которая меняет местами два элемента, встречается в quicksort трижды, поэтому лучше всего вынести ее в отдельную функцию:

/* swap:

поменять местами v[i] и v[j] */ void swap(int v[], int i, int j) { int temp;

temp = v[i];

v[i] = v[j];

v[j] = temp;

При разделении прежде всего случайным образом выбирается элемент разделитель, который временно переставляется в начало массива, затем просматриваются остальные. Элементы, меньшие разделителя ("маленькие" элементы), перемещаются ближе к началу массива (на позицию last), а "большие" элементы — в сторону конца массива (на позицию i). В начале процесса, сразу после перемещения разделителя в начало, last = 0 и элементы с i = 1 по n-1 еще не исследованы:

В начале 1-й итерации элементы с первого по last строго меньше разделителя, элементы с last+1 no i-1 больше или равны разделителю, а элементы с i по п-1 еще не рассмотрены. Пока не выполнилось первый раз условие v[i] >='v[0], алгоритм будет переставлять элемент v[i] сам с собой;

это, конечно, занимает дополнительное время, но не столь страшно.

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

тогда порядок элементов будет правильным. Теперь массив выглядит так:

Та же самая операция применяется к левой и правой частям массива;

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

Насколько быстро работает быстрая сортировка? В наилучшем случае первый проход делит массив из п элементов на две группы примерно по п/ • элементов;

второй проход разделяет две группы по п/2 элементов на 4 группы, в каждой • из которых примерно по п/4 элементов;

на следующем проходе четыре группы по п/4 делятся на восемь групп по • (примерно) п/8 элементов;

и т. д.

• Данный процесс продолжается примерно Iog2 n раз, поэтому общее время работы в лучшем случае пропорционально п + 2 X и/2 + 4 х и/4 + + 8 X п/8... (Iog2 и слагаемых), что равно п log? п. В среднем алгоритм работает совсем не намного дольше. Обычно принято использовать именно двоичные логарифмы, поэтому мы можем сказать, что быстрая сортировка работает пропорционально n long.

Эта демонстрационная реализация быстрой сортировки наиболее прозрачна, но у нее есть одна слабина. Если каждый выбор разделителя разбивает массив на две примерно одинаковые группы, то наш анализ корректен, однако если разделение слишком часто происходит неровно, то время работы будет расти скорее как п1. В нашей реализации в качестве разделителя берется случайный элемент, чтобы уменьшить шанс того, что плохие входные данные приведут к слишком большому количеству неровных разбиений массива. Но если все входные значения одинаковы, то наша реализация за каждый проход будет отделять только один элемент, поэтому время работы будет расти как п2.

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

Библиотеки В стандартные библиотеки языков С и C++ входят функции сортировки, которые устойчивы к неблагоприятным входным данным и настроены на предельно быструю работу.

Библиотечные функции написаны так, что они могут сортировать данные любого типа, но мы в свою очередь должны адаптироваться к их интерфейсу, что может быть несколько сложнее, чем в рассмотренном выше примере. В языке С библиотечная функция называется qso rt, и ей нужно предоставлять функцию сравнения двух значений. Поскольку значения могут быть любых типов, то функции сравнения передаются два нетипизированных указателя (void *) на сравниваемые значения. Функция преобразует указатели к нужному типу, извлекает значения данных, сравнивает их и возвращает результат (отрицательный, нуль или положительный в зависимости от того, меньше ли первый элемент, равен ли второму или больше его).

Рассмотрим реализацию функции сравнения для сортировки массива строк, случая, встречающегося довольно часто. Мы написали функцию scmp, которая -преобразует параметры к другому типу и затем вызывает st rcmp для выполнения самого сравнения:

/* scmp: сравнение строк *р1 и *р2 */ int scmp(const void *p1, const void *p2) { char *v1, *v2;

v1 = *(char **) p1;

v2 = *(char **) p2;

return strcmp(v1, v2);

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

Мы не можем напрямую использовать strcmp как функцию сравнения, поскольку qsort передает адрес каждого элемента в массиве &s t г [ i ] (типаспаг **), ане str[i] (типа char *), как показано на рисунке:

Для сортировки элементов массива строк с st r[0] по st r[N-1 ] функция qsort должна получить массив, его длину, размер сортируемых элементов и функцию сравнения:

char *str[N];

qsort(str, N, sizeof(str[OJ), scmp);

А вот аналогичная функция icmp для сравнения целых:

{ int v1, v2;

v1 = *(int *) p1;

v2 = *(int *.) p2;

if (v1 < v2) return -1;

else if (v1 == v2) return 0;

else return 1;

> } Мы могли бы написать ? return v1-v2;

но если v2 — большое положительное число, a v1 — большое по абсолютному значению отрицательное или наоборот, то получившееся переполнение привело бы к неправильному ответу. Прямое сравнение длиннее, но надежнее.

И здесь при вызове qsort нужно передать массив, его длину, размер сортируемых элементов и функцию сравнения:

int arr[N];

qsort(arr, N, sizeof(arr[0]), icmp);

В стандарте ANSI С определена также функция двоичного поиска bsea rch. Как и qso rt, этой функции нужен указатель на функцию сравнения (часто на ту же, что используется для qsort);

bsearch возвращает указатель на найденный элемент или на NULL, если такого элемента нет. Вот наша программа для поиска имен в HTML файле, переписанная с использованием bsearch:

/* lookup: использует bsearch для поиска name в таблице tab, возвращает индекс */ int lookup(char *name, Nameval tab[], int ntab) { Nameval key, *np;

key.value = 0;

/* не используется;

годится любое значение */ np = (Nameval *) bsearch(&key, tab, ntab, sizeof(tab[0]), nvcmp);

if (np == NULL) return -1;

else return np-tab;

Как и в случае qsort, функция сравнения получает адреса сравниваемых значений, поэтому ключевое (искомое) значение должно иметь этот же тип;

в данном примере нам пришлось создать фиктивный элемент типа Nameval для передачи в функцию сравнения. Сама функция сравнения nvcmp сравнивает два значения типа Nameval, вызывая st rcmp для их строковых компонентов, полностью игнорируя численные компоненты:

/* nvcmp: сравнивает два вначения типа Nameval */ int nvcmp(const void *va, const void *vb) { const Nameval *a, *b;

a = (Nameval *) va;

* b = (Nameval *) vb;

return strcmp(a->name, b->name);

} Это похоже на scmp, только с тем отличием, что строки хранятся как члены структуры.

Неудобство передачи ключевого значения показывает, что bsearch предоставляет меньше возможностей, чем qso rt. Хорошая многоцелевая функция сортировки занимает одну-две страницы кода, а двоичный поиск — ненамного больше, чем код для интерфейса с bsearch. Тем не менее лучше использовать bsearch, чем писать свою собственную версию. Как показывает опыт, программистам на удивление трудно написать двоичный поиск без ошибок.

В стандартной библиотеке C++ имеется обобщенная функция sort, которая обеспечивает время работы 0(п log n). Код для ее вызова проще, потому что нет необходимости в преобразовании типов и размеров элементов. Кроме того, для порядковых типов не требуется задавать функцию сравнения:

int arr[N];

sort(arr, arr+N);

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

Упражнение 2- Алгоритм быстрой сортировки проще всего выразить рекурсивно. Реализуйте его итеративно и сравните две версии. (Хоар рассказывает, как было трудно разработать итеративный вавариант быстрой сортировки и как легко все оказалось, когда он сделал ее рекурсивной.) Быстрая сортировка на языке Java В Java ситуация другая. В ранних версиях не было стандартной функции сортировки, поэтому приходилось писать собственную. В последних версиях появилась такая функция, работающая с классами, реализующими интерфейс Comparable, поэтому теперь мы можем просить библиотеку сортировать то, что нам потребуется. Но поскольку используемые технологии полезны и в других ситуациях, в данном разделе мы опишем все детали реализации быстрой сортировки в Java.

Адаптировать быструю сортировку для каждого конкретного типа данных легко;

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

Одно из крупных отличий от С и C++ заключается в том, что в Java мы не можем передать функцию сравнения в другую функцию — здесь не существует указателей на функции. Вместо этого мы создаем интерфейс (interface), единственным содержимым которого будет функция, сравнивающая два объекта типа Object. Далее для каждого сортируемого типа данных мы создаем класс с функцией (методом), которая реализует интерфейс для этого типа данных. Мы передаем экземпляр класса в функцию сортировки, которая в свою очередь использует функцию сравнения из этого класса для сравнения элементов.

Сначала опишем интерфейс Стр, который определяет единственную функцию стр, сравнивающую два значения типа Object:

interface Cmp { int cmp(0bject x, Object y);

} Теперь мы можем написать функции сравнения, которые реализуют этот интерфейс;

например, следующий класс определяет функцию, сравнивающую объекты типа Integer:

// Icmp: сравнение целых class Icmp implements Cmp { public int cmp(0bject o1, Object o2) { int 11 = ((Integer) o1). intValueO;

int 12 = ((Integer) o2). intValueO;

if (11 < 12) return -1;

else if (11 == 12) return 0;

else return 1;

} } ;

а эта функция сравнивает объекты типа St ring:

// Scmp: сравнение строк class Scmp implements Cmp { public int cmp(0bject o1, Object o2) { String s1 = (String) o1;

String s2 = (String) o2;

return s1.compareTo(s2);

}} Данным способом можно сортировать только типы, наследуемые от класса Object;

подобный механизм нельзя применять для базовых типов, таких как int или double.

Поэтому мы сортируем элементы типа Integer, а не int.

С этими компонентами мы теперь можем перенести функцию быстрой сортировки из языка С в Java и вызывать в ней функцию сравнения из объекта Стр, переданного параметром. Наиболее существенное изменение — это использование индексов left и right, поскольку в Java нет указателей на массивы.

// Quicksort.sort: сортировать v[left]..v[right] // алгоритмом quicksort static void sort(0bject[] v, int left, int right, Cmp cmp) { int i, last;

if (left >= right) // ничего делать не надо return;

swap(v, left, rand(left,right));

// поместить разделитель last = left;

// в v[left] for (i = left+1;

i <= right;

i++) // разделить массив if (cmp.cmp(v[i], v[left]) < 0) swap(v, ++last, i);

swap(v, left, last);

// вернуть разделитель sort(v, left, last-1, cmp);

// рекурсивно отсортировать sort(v, last+1, right, cmp);

// обе части } Quicksort.sort использует cmp для сравнения двух объектов, как и раньше, вызывает swap для их обмена.

// Quicksort.swap: обменять v[i] и v[j] static void swap (0bject[] v, int i, int j) { Object temp;

temp = v[i];

v[i] = v[j] ;

v[j] = temp;

} Генерация случайного номера происходит в функции rand, которая а возвращает случайное число в диапазоне с left по right включительно:

static Random rgen = new Random();

// Quicksort, rand: возвращает случайное целое число // из [left, right] static int rand(int left, int right) { return left + Math.abs (rgen.nextlnt())%(right-left+1);

} Мы вычисляем абсолютное значение (используя функцию Math.abs), поскольку в Java генератор случайных чисел возвращает как положительные, так и отрицательные значения.

Функции sort, swap и rand, а также объект-генератор случайных чисел rgen являются членами класса Quicksort.

Наконец мы готовы написать вызов Quicksort, sort для сортировки массива типа String:

String[] sarr = new String[n];

// заполнить n элементов sarr...

Quicksort. sort (sarr, 0, sarr. length-1, new ScmpO);

Так вызывается so rt с объектом сравнения строк, созданным для этой цели.

Упражнение 2- Наша реализация быстрой сортировки в Java делает несколько преобразований типов, сначала переводя исходные данные из их первоначального типа (вроде Integer) в Object, а затем обратно. Поэкспериментируйте с версией Quickso rt. so rt, которая использует конкретный тип при сортировке, и попробуйте вычислить, какие потери производительности вызываются преобразованием типов.

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

при использовании двоичного поиска по отсортированным данным время будет пропорционально log п. Время сортировки пропорционально n2 или n logn.

Нам нужно как-то уточнить эти высказывания, при этом абстрагируясь от таких деталей, как скорость процессора и качество компилятора (и программиста).

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

Для этой цели существует стандартная форма записи, которая называется "О большое". Основной параметр этой записи — п, размер входных данных, а сложность или время работы алгоритма выражается как функция от п. "О" — от английского order, то есть порядок. Например, фраза "Двоичный поиск имеет сложность 0(log n)" означает, что для поиска в массиве из п элементов требуется порядка log n действий. Запись О(f(n)) предусматривает, что при достаточно больших п время выполнения пропорционально f(n), не быстрее, например, О(n2) или 0(n log n). Асимптотические оценки вроде этой полезны при теоретическом анализе и грубом сравнении алгоритмов, однако на практике разница в деталях может иметь большое значение. Например, алгоритм класса 0(n2) с малым количеством дополнительных вычислений для малых п может работать быстрее, чем сложный алгоритм класса О(n logn), однако при достаточно большом п алгоритм с медленнее возрастающей функцией поведения неизбежно будет работать быстрее.

Нам нужно различать также случаи наихудшего и ожидаемого поведения. Трудно строго определить, что такое "ожидаемое" поведение, потому что определение зависит от наших предположений о возможных входных данных. Обычно мы можем точно указать самый плохой случай, хотя иногда и здесь можно ошибиться. Для quicksort в самом плохом случае время работы растет как О(n2), а среднее ("ожидаемое") время — как О(n log n). Если каждый раз аккуратно выбирать элемент разделитель, то мы можем свести вероятность квадратичного (то есть 0(n2)) поведения практически к нулю;

хорошо реализованная quicksort действительно обычно ведет себя как О(n log n).

Вот основные случаи:

Запись Название времени Пример 0(1) Константное Индексирование массива 0(log n) Логарифмическое Двоичный поиск 0(n) Линейное Сравнение строк n logn Quicksort 0(n log n) 0(n2) Квадратичное Простые методы сортировки О(n ) Кубическое Перемножение матриц n 0(2 ) Экспоненциальное Перебор всех подмножеств Доступ к элементу в массиве — операция, работающая за константное (О(1)) время.

Алгоритм, за каждый шаг отсеивающий половину входных данных, как двоичный поиск, обычно займет время 0(log n). Сравнение двух строк длиной в n символов с помощью strcmp займет О(n).

Традиционный алгоритм перемножения двух квадратных матриц порядка п занимает О(и!), поскольку каждый элемент получается в результате перемножения и пар чисел и суммирования результатов, а всего элементов n2.

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

Упражнение 2- Каковы входные данные для алгоритма quicksort, которые заставляют его работать медленнее всего, как в наихудшем случае? Попробуйте найти несколько наборов данных, сильно замедляющих библиотечную версию алгоритма. Автоматизируйте процесс, чтобы вы легко могли задавать параметры и проводить большое число экспериментов.

Упражнение 2- Придумайте и реализуйте алгоритм, который будет сортировать массив из п целых как можно медленнее. Только напишите его честно: алгоритм должен постепенно прогрессировать и в конце концов завершиться, и ваша реализация не должна использовать всяческие трюки вроде лишних пустых циклов. Какова получилась сложность вашего алгоритма как функция от n?

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

Вставка в отсортированный массив п элементов по одному занимает О(n2), чего стоит избегать при больших n.

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

Следующий код определяет расширяемый массив с элементами типа Nameval:

новые элементы добавляются в хвост массива, который удлиняется при необходимости. Доступ к каждому элементу по его индексу происходит за константное время. Эта конструкция аналогична векторным классам из библиотек C++ и Java.

typedef struct Nameval Nameval;

struct Nameval { char *name;

int value;

};

struct NVtab { int nval;

/* текущее количество элементов */ int max;

/* под сколько элементов выделена память */ Nameval *nameval;

/* массив пар */ } nvtab;

enum { NVINIT = 1, NVGROW = 2 };

/* addname: добавить новое имя и значение в nvtab */ int addname(Nameval newname) { Nameval *nvp;

if (nvtab.nameval == NULL) { /* первый вызов */ nvtab.nameval = (Nameval *) malloc(NVINIT * sizeof(Nameval));

if (nvtab.nameval == NULL) return -1;

nvtab.max = NVINIT;

nvtab.nval = 0;

} else if (nvtab.nval >= nvtab.max) { /* расширить */ nvp = (Nameval *) realloc(nvtab.nameval, (NVGROW*nvtab.max) * sizeof(Nameval));

if (nvp == NULL) return -1;

nvtab.max *= NVGROW;

nvtab.nameval = nvp;

} nvtab.nameval[nvtab.nval] = newname;

return nvtab.

Функция addname возвращает индекс только что добавленного элемента или -1 в случае возникновения ошибки.

Вызов reallос увеличивает массив до новых размеров, сохраняя существующие элементы, и возвращает указатель на него или NULL при недостатке памяти.

Удвоение размера массива при каждом вызове realloc сохраняет средние "ожидаемые" затраты на копирование элемента постоянными;

если бы массив увеличивался каждый раз только на один элемент, то производительность была бы порядка 0(п2). Поскольку при перераспределении памяти адрес массива может измениться, то программа должна обращаться к элементам массива по индексам, а не через указатели. Заметьте, что код не таков:

? nvtab.nameval = (Nameval *) realloc(nvtab.nameval, ? (NVGROW*nvtab.jnax) * sizeof (Nameval));

потому что при такой форме если вызов realloc не сработает, то исходный массив будет утерян.

Мы задаем очень маленький начальный размер массива (NVINIT = 1). Это заставляет программу увеличивать массив почти сразу, что гарантирует проверку данной части программы. Начальное значение может быть и увеличено, когда программа начнет реально использоваться, однако затраты на стартовое расширение массива ничтожны.

Значение, возвращаемое realloc, не обязательно должно приводиться к его настоящему типу, поскольку в С нетипизированные указатели (void *) приводятся к любому типу указателя автоматически. Однако в C++ это не так;

здесь преобразование обязательно. Можно поспорить, что безопаснее: преобразовывать типы (это честнее и понятнее) или не преобразовывать (поскольку в преобразовании легко может закрасться ошибка). Мы выбрали преобразование, потому что тогда программа корректна как в С, так и в C++. Цена такого решения — уменьшение количества проверок на ошибки компилятором С, но это неважно, когда мы производим дополнительные проверки с помощью двух компиляторов.

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

/* delname: удалить первое совпавшее имя в массиве nvtab */ int delname(char *name) { int i;

for (i = 0;

i < nvtab.nval;

i++) if (strcmp(nvtab.nameval[i].name, name) == 0) { meminove(nvtab. nameval+i, nvtab.

nameval'+i+1, (nvtab.nval-(i+1) ) * sizeof(Nameval));

nvtab.nval--;

return 1;

} return 0:

} Вызов memmove сдвигает массив, перемещая элементы вниз на одну позицию;

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

В стандарте ANSI определены две функции: memcpy, которая работает быстрее, но может затереть память, если источник и приемник данных пересекаются, и memmove, которая может работать медленнее, но зато всегда корректна. Бремя выбора между скоростью и корректностью не должно взваливаться на программиста;

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

Мы могли бы заменить вызов memmove следующим циклом:

nt j;

for (j = i;

j < nvtab.nval-1;

j++) nvtab.namevalfj] = nvtab.nameval[j+1];

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

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

Массивы — простейший способ группировки данных;

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

Упражнение 2- В приведенном выше коде функция delname не вызывает realloc для возврата системе памяти, освобожденной удалением элемента. Имеет ли смысл это делать?

Как решить, стоит это делать или нет?

Упражнение 2- Внесите необходимые изменения в функции delname и addname, чтобы удаленные элементы помечались как неиспользуемые. Насколько остальная программа не зависит от этого изменения?

Списки По своей встречаемости в типичных программах списки занимают второе место после массивов. Многие языки имеют встроенные типы списков, некоторые, такие как Lisp, даже построены на них, но в языке С мы должны конструировать их самостоятельно. В C++ и Java работа со списками поддерживается стандартными библиотеками, но и в этом случае нужно знать их возможности и типичные применения. В данном параграфе мы собираемся обсудить использование списков в С, но уроки из этогр обсуждения можно извлечь и для более широкого применения.

Простым цепным списком (single-linked list) называется последовательность элементов, каждый из которых содержит данные и указатель на следующий элемент.

Головой списка является указатель на первый элемент, а конец помечен нулевым указателем. Ниже показан список из четырех элементов:

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

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

Эти различия подсказывают, что если набор данных будет часто меняться, особенно при непредсказуемом количестве элементов, то нужно использовать список;

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

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

Вместо того чтобы определить специальный тип List, обычно в С начинают определение списка с описания типа для элементов, вроде нашего Nameval, и добавляют в него указатель на следующий элемент:

typedef struct Nameval Nameval;

struct Nameval { char *name:

int value;

Nameval «next;

/* следующий в списке */ };

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

/* newitem: создать новый элемент по полям name и value */ Nameval *newitem(char *name, int value) { Nameval *newp;

newp = (Nameval *) emalloc(sizeof(Nameval));

newp->name = name;

newp->value = value;

newp->next = NULL;

return newp;

} Функцию emalloc мы будем использовать и далее во всей книге;

она вызывает mall ос, а при ошибке выделения памяти выводит сообщение и завершает программу. Мы представим код этой функции в главе 4, а пока считайте, что эта функция всегда корректно и без сбоев выделяет память.

Простейший и самый быстрый способ собрать список — это добавлять новые элементы в его начало:

/* addfront: добавить элемент newp в начало списка listp */ Nameval *addfront (Nameval *listp, Nameval *newp) { newp->next = listp;

return newp;

} При изменении списка у него может измениться первый элемент, что и происходит при вызове addf ront. Функции, изменяющие список, должны возвращать указатель на новый первый элемент, который хранится в переменной, указывающей на список.

Функция addfront и другие функции этой группы передают указатель на первый элемент в качестве возвращаемого значения;

вот типичное использование таких функций:

nvlist = addf ront(nvlist, newitem( "smiley", Ox263A));

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

Добавление элемента в конец списка — процедура порядка 0(п), поскольку нам нужно пройтись по всему списку до конца:

/* addend: добавить элемент newp в конец списка listp */ Nameval *addend(Nameval *listp, Namevai *newp) { Nameval *p;

if (listp == NULL) return newp;

for (p = listp;

p->next != NULL;

p = p->next) p->next = newp;

return listp;

} Чтобы сделать addend операцией порядка 0(1), мы могли бы завести отдельный указатель на конец списка. Недостаток этого подхода, кроме того, что нам нужно заботиться о корректности этого указателя, состоит в том, что список теперь уже представлен не одной переменной, а двумя. Мы будем придерживаться более простого стиля.

Для поиска элемента с заданным именем нужно пройтись по указателям next:

/* lookup: последовательный поиск имени в списке */ Nameval *lookup(Nameval *listp, char *name) { for ( ;

listp != NULL;

listp = listp->next) if (strcmp(name, listp->name) == 0) return listp;

return NULL;

/* нет совпадений */ } Поиск занимает время порядка 0(п), и, в принципе, эту оценку не улучшить. Даже если список отсортирован, нам все равно нужно пройтись по нему, чтобы добраться до нужного элемента. Двоичный поиск к спискам неприменим.

Для печати элементов списка мы можем написать функцию, проходящую по списку и печатающую каждый элемент;

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

Таким образом, у apply три аргумента: сам список, функция, которую нужно применить к каждому элементу списка, и аргумент для этой функции:

/* apply: применить функцию fn для каждого элемента списка listp */ void apply(Nameval *listp, void (*fn)(Nameval*, void*), void *arg) { for ( ;

listp != NULL;

listp = listp->next) (*fn)(listp, arg);

/* вызов функции */ } Второй аргумент apply — указатель на функцию, которая принимает два параметра и возвращает void. Стандартный, хотя и весьма неуклюжий, синтаксис * void (*fn)(Nameval*, void*) определяет f n как указатель на функцию с возвращаемым значением типа void, то есть как переменную, содержащую адрес функции, которая возвращает void.

Функция имеет два параметра — типа Nameval * (элемент списка) и void * (обобщенный указатель на аргумент для этой функции).

Для использования apply, например для вывода элементов списка, мы можем написать тривиальную функцию, параметр которой будет восприниматься как строка форматирования:

/* printnv: вывод имени и значения с использованием формата в arg */ void printnv(Nameval *p, void *arg) { char *fmt;

fmt = (char *) arg;

printf(fmt, p->name, p->value);

} тогда вызывать мы ее будем так:

apply(nvlist, printnv, "%s: %x\n");

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

/* inccounter: увеличить счетчик *arg */ void inccounter(Nameval *p, void *arg) { int *ip;

/*' p не используется */ ip = (int *) arg;

(*ip)++;

} Вызывается она следующим образом:

int n;

n = 0;

apply(nvlist, inccounter, &n);

printf("B nvlist %d элементов\n", n);

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

/* freeall:

освободить все элементы списка listp */ void freeall(Nameval *listp) { Nameval *next;

for ( ;

listp != NULL;

listp = next) { next = listp->next;

/* считаем, что память, занятая строкой name, освобождена где-то в другом месте */ free(listp);

} } Память нельзя использовать после того, как мы ее освободили, поэтому до освобождения элемента, на который указывает listp, указатель listp->next нужно сохранить в локальной переменной next. Если бы цикл, как и раньше, выглядел так:

? for ( ;

listp != NULL;

listp = listp->next) ?

free(listp);

то значение listp->next могло быть затерто вызовом free и код бы не работал.

Заметьте, что функция freeall не освобождает память, выделенную под строку listp >name. Это подразумевает, что поле name каждого элемента типа Nameval было освобождено где-то еще либо память под него не была выделена. Чтобы обеспечить корректное выделение памяти под элементы и ее освобождение, нужно согласование работы newitem и f гее-all;

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

Удаление одного элемента из списка — более сложный процесс, чем добавление:

/* delitem: удалить первое вхождение "name" в listp */ Nameval *delitem(Nameval *listp, char *name) { Nameval *p, *prev;

prev = NULL;

for (p = listp;

p != NULL;

p = p->next) { if (strcmp(name, p->name) == 0) { if (prev == NULL) listp = p->next;

else prev->next = p->next;

f ree(p);

return listp;

} prev = p;

} eprintf("delitem: %s в списке отсутствует", name);

return NULL;

/* сюда не дойдет */ } Как и в f reeall, delitem не освобождает память, занятую полем namе.

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

Представленные основные списочные структуры и операции применимы в подавляющем большинстве случаев, которые могут встретиться в ваших программах. Однако есть много альтернатив. Некоторые библиотеки, включая библиотеку стандартных шаблонов (Standard Template Library, STL) в C++, поддерживают двухсвязные списки (double-linked lists: списки с двойными связями), в которых у каждого элемента есть два указателя: один — на последующий, а другой — на предыдущий элемент. Двухсвязные списки требуют больше ресурсов, но поиск последнего элемента и удаление текущего — операции порядка О( 1). Иногда память под указатели списка выделяют отдельно от данных, которые они связывают;

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

Кроме того, что списки годятся для ситуации, когда происходят удаления и вставки элементов в середине, они также хороши для управления данными меняющегося размера, особенно когда доступ к ним происходит по принципу стека: последним вошел, первым вышел (last in, first out — LIFO). Они используют память эффективнее, чем массивы, при наличии нескольких стеков, которые независимо друг от друга растут и уменьшаются. Они также хороши в случае, когда информация внутренне связана в цепочку неизвестного заранее размера, например как последовательность слов в документе. Однако если вам нужны как частые обновления, так и случайный доступ к данным, то разумнее будет использовать не такую непреклонно линейную структуру данных, а что-нибудь вроде дерева или хэш таблицы.

Упражнение 2- Реализуйте некоторые другие операции над списком: копирование, слияние, разделение списка, вставку до или после указанного элемента. Как эти две операции вставки отличаются по сложности? Много ли вы можете использовать из того, что мы написали, и много ли вам надо написать самому?

Упражнение 2- Напишите рекурсивную и итеративную версии процедуры reverse, переворачивающей список. Не создавайте новых элементов списка;

используйте старые.

Упражнение 2- Напишите обобщенный тип List для языка С. Простейший способ — в каждом элементе списка хранить указатель void *, который ссылается на данные. Сделайте то же для C++, используя шаблон (template), и для Java, определив класс, содержащий списки типа Obj ect. Каковы сильные и слабые стороны этих языков с точки зрения данной задачи?

Упражнение 2- Придумайте и реализуйте набор тестов для проверки того, что написанные вами процедуры работы со списками корректны. Стратегии тестирования подробнее обсуждаются в главе 6.

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

Входящие в дерево элементы называются его вершинами.

Есть много типов деревьев, которые отражают сложные структуры, например деревья синтаксического разбора (parse trees), хранящие синтаксис предложения или программы, либо генеалогические деревья, описывающие родственные связи.

Мы продемонстрируем основные принципы на деревьях двоичного поиска, в которых каждая вершина (node) имеет по две связи. Они наиболее просто реализуются и демонстрируют наиболее важные свойства деревьев. Вершина в двоичном дереве имеет значение и два указателя, left и right, которые показывают на его дочерние вершины. Эти указатели могут быть равны null, если у вершины меньше двух дочерних вершин. Структуру двоичного дерева поиска определяют значения в его вершинах: все дочерние вершины, расположенные левее данной, имеют меньшие значения, а все дочерние вершины правее — большие. Благодаря этому свойству мы можем использовать разновидность двоичного поиска для быстрого поиска значения по дереву или определения, что такого значения нет.

Вариант структуры Nameval для дерева пишется сразу:

typedef struct Namevai Nameval;

struct Nameval { char *name;

int value;

Nameval *left;

/* меньшие */ Nameval * right;

/* большие */ };

Комментарии "большие" и "меньшие" относятся к свойствам связей: левые "дети" хранят меньшие значения, правые — большие.

В качестве конкретного примера на приведенном рисунке показано подмножество таблицы символов в виде дерева двоичного поиска для структур Nameval, отсортированных по ASCII-значениям имен символов.

Поскольку в каждой вершине дерева хранится несколько указателей на другие элементы, то многие операции, занимающие время порядка О(п) в списках или массивах, занимают только 0(log n) в деревьях. Наличие нескольких указателей в каждой вершине сокращает время выполнения операций, так как уменьшается количество вершин, которые необходимо посетить, чтобы добраться до нужной.

Дерево двоичного поиска (которое в данном параграфе мы будем называть просто "деревом") достраивается рекурсивным спуском по дереву;

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

/* insert: вставляет вершину newp в дерево treep, возвращает treep */ Nameval *insert(Nameval *treep, Nameval *newp) { int cmp;

if (treep == NULL) return newp;

cmp = strcmp(newp->name,~treep->name);

if (cmp == 0) weprintf("insert: дубликат значения %s проигнорирован", newp->name);

else if (cmp < 0) treep->left = *insert(treep->left, newp);

else treep->right = insert(treep->right, newp);

return treep;

} Мы ничего еще не сказали о дубликатах — повторах значений. Данная версия insert сообщает о попытке вставки в дерево дубликата (cmp == 0). Процедура вставки в список ничего не сообщала, поскольку для обнаружения дубликата надо было бы искать его по всему списку, в результате чего вставка происходила бы за время О(п), а не за 0(1). С деревьями, однако, эта проверка оставляется на произвол программиста, правда, свойства структуры данных не будут столь четко определены, если будут встречаться дубликаты. В других приложениях может оказаться необходимым допускать дубликаты или, наоборот, обязательно их игнорировать.

Процедура weprintf — это вариант eprintf;

она печатает сообщение, начинающееся со слова warning (предупреждение), но, в отличие от eprintf, работу программы не завершает.

Дерево, в котором каждый путь от корня до любого листа имеет примерно одну и ту же длину, называется сбалансированным. Преимущество сбалансированного дерева в том, что поиск элемента в нем занимает время порядка 0(log n), поскольку, как и в двоичном поиске, на каждом шаге отбрасывается половина вариантов.

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

Трудно реализовать деревья, которые гарантированно сбалансированы;

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

Код для функции поиска похож на функцию insert:

/* lookup: поиск имени name в дереве treep */ Nameval *lookup(Nameval *treep, char *name) { int cmp;

if (treep == NULL) return NULL;

cmp = strcmp(name, treep->name);

if (cmp == 0) return treep;

else if (cmp < 0) return lookup(treep->left, name);

else return lookup(treep->right, name);

} У нас есть еще пара замечаний по поводу функций lookup и i nse rt. Во-первых, они выглядят поразительно похожими на алгоритм двоичного поиска из начала главы.

Это вовсе не случайно, так как они построены на той же идее "разделяй и властвуй", что и двоичный поиск, — основе логарифмических алгоритмов.

Во-вторых, эти процедуры рекурсивны. Если их переписать итеративно, то они будут похожи на двоичный поиск еще больше. На самом деле итеративная версия функции lookup может быть создана в результате элегантной трансформации рекурсивной версии. Если мы еще не нашли элемента, то последнее действие функции заключается в возврате результата, получающегося при вызове себя самой, такая ситуация называется хвостовой рекурсией (tail recursion). Эта конструкция может быть преобразована в итеративную форму, если подправить аргументы и стартовать функцию заново. Наиболее прямой метод — использовать оператор перехода goto, но цикл while выглядит чище:

/* nrlookup: нерекурсивный поиск имени в дереве treep */ *Nameval *nrlookup (Nameval *treep, char *name) int cmp;

while (treep != NULL) { cmp = strcmp(name, treep->name);

if (cmp == 0) return treep;

else if (cmp < 0) treep = treep->left;

else treep = treep->right;

} return NULL;

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

Иногда структура дерева отражает какое-то внутреннее упорядочение данных, как в генеалогических деревьях, и порядок обхода листьев будет зависеть от отношений, которые дерево представляет.

Фланговый порядок (in-order) обхода выполняет операцию в данной вершине после просмотра ее левого поддерева и перед просмотром правого:

/* applyinorder: применение функции fn во время обхода дерева во фланговом порядке */ void applyinorder(Nameval *treep, void (*fn)(Nameval*, void*), void *arg) { if (treep == NULL) return;

applyinorder(treep->left, fn, arg);

(*fn)(treep, arg);

applyinorder(treep->right, fn, arg);

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

applyinorder(treep, printnv, "%s: %x\n");

Сразу намечается вариант сортировки: вставляем элементы в дерево, выделяем память под массив соответствующего размера, а затем используем фланговый обход для последовательного размещения их в массиве. Восходящий порядок (post order) обхода вызывает операцию для данной вершины после просмотра вершин детей:

* applypostorder: применение функции fn во время обхода дерева в восходящем порядке */ void applypostorder(Nameval *treep, void (*fn)(Nameval*, void*), void *arg) { if (treep == NULL) return;

applypostorder(treep->left, fn, arg);

applypostorder(treep->right, fn, arg);

(*fn)(treep, arg);

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

Нисходящий порядок (pre-order) используется редко, так что мы не будем его рассматривать.

Pages:     || 2 | 3 | 4 | 5 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.