Правила программирования на С и С++. Главы 1-6
ОГЛАВЛЕНИЕ
Я профессионально занимаюсь программированием примерно с 1979 года и ежедневно пользуюсь правилами из этой книги. Я не утверждаю, что эти правила безусловны, или даже "верны". Однако я могу сказать, что они отлично мне служили все это время. Хотя эта книга не относится к категории путеводителей по "ловушкам и рытвинам", многие из этих правил предохранят вас от неприятностей того сорта, который обсуждается в путеводителях по "ловушкам и рытвинах".
Практические правила по своей сути гибки. Они постепенно меняются с ростом опыта, и ни одно правило не действует постоянно. Тем не менее я предупреждаю вас с самого начала, что мое мнение относительно этого материла самое наилучшее и что я не очень симпатизирую неряшливым мыслям или небрежному программированию. Я не извиняюсь за усиленное подчеркивание тех вещей, в которые я сильно верю. Мои мнения всегда могут измениться, если, конечно, вы сможете убедить меня в том, что я не прав, но имейте в виду, что эта книга основана на опыте, а не на теории. Я сознаю, что большая часть этой книги подходит опасно близко к чьему-то культу и многие вещи, произносимые мной, дискуссионны, но думаю, что всегда имеется возможность разумного разговора двух людей, объединенных целью совершенствования своего мастерства.
Я часто читаю курсы по С++ и объектно-ориентированному проектированию как по приглашению частных фирм, так и в Калифорнийском университете в Беркли. Эта книга появилась в ответ на просьбы моих студентов, большинство из которых увлеченные профессионалы с настоящим желанием изучить этот материал. Я вижу множество программ в процессе проверки домашних заданий, и эти программы достаточно репрезентативны в качестве произведений сообщества профессиональных программистов из района залива Сан-Франциско. К несчастью, каждый семестр я также вижу, что одни и те же проблемы повторяются снова и снова. Поэтому эта книга является некоторым образом и списком распространенных проблем, найденных мной в созданных настоящими программистами реальных программах, сопровождаемым моими советами по их решению.
Обсуждаемые здесь проблемы программирования и проектирования не ограничиваются, к несчастью, лишь ученическими программами. Многие из примеров того, что не следует делать, взяты из коммерческого продукта: библиотеки классов Micrisoft Foundation Class(MFC) корпорации Micrisoft. Я могу сказать, что эта библиотека была спроектирована без заботы о хорошем сопровождении людьми, не подозревающими о существовании даже элементарных принципов объектно-ориентированного проектирования. Я не выделял явно большинство примеров этого в тексте, так как это не книга с названием "Что неправильно в MFC"; пользователи библиотеки MFC узнают ее код, когда натолкнутся на него. Я выбрал примеры из MFC просто потому, что мне пришлось много с ней работать и очень близко познакомиться с ее недостатками. Во многих других коммерческих библиотеках классов имеются сходные проблемы.
Наконец, эта книга не является введением в С++. Обсуждение, сопровождающее относящиеся к С++ правила, предполагает, что вы знаете этот язык. Я не расходую место на описание того, как работает С++. Имеется множество хороших книг, которые учат вас языку С++, включая мою собственную C+C++ (New York, McGraw-Hill,1993). Вы должны также ознакомиться с принципами объектно-ориентированного проектирования. Я рекомендую второе издание книги Гради Буча Object-Oriented Analysis and Design with Applications (Redwood City, Benjamin Cummings,1994).
О нумерации правил: иногда я группировал некоторые правила вместе, потому что удобно описывать их все одновременно. В этом случае все эти правила (имеющие различные номера) располагаются в начале раздела. Я использовал запись номера правила вида "1.2" в случаях, когда оно является особым случаем другого правила.
Глава 1. Процесс проектирования
Эта глава вместе с последующей, посвященной разработке, являются наиболее туманными главами в этой книге. Правила здесь довольно общего характера по своей природе, они совсем не затрагивают техники программирования на С или С++, а скорее рассматривают более общий процесс проектирования и разработки программы.Правила из данной главы относятся к процессу общего проектирования. После прочтения этой главыи в законченном виде я стал беспокоиться, что многие из этих правил будут казаться банальными. Несмотря на это, некоторые из приводимых здесь правил являются самыми важными в этой книге, потому что нарушение их может вызвать много бед в процессе разработки. В известном смысле, многие из правил в этой главыи предназначены для управленцев; программисты их часто знают, но у них нет свободы, необходимой, чтобы воспользоваться своими знаниями.
1. Сущность программирования: без сюрпризов, минимум сцепления и максимум согласованности.
Многие (если не все) правила в этой книге могут быть объединены в три метаправила (при желании), выраженные в заголовке этого раздела.
Правило "без сюрпризов" не требует пояснений само по себе. Пользовательский интерфейс должен действовать так, как кажется он должен действовать. Функция или переменная должны делать то, что означают их имена.
Сцепление - это связь между двумя программами или объектами пользовательского интерфейса. Когда один объект меняется, то все, с чем он соединен, может также измениться. Сцепление способствует сюрпризам. (Я меняю эту штучку здесь, и внезапно та штуковина вон там перестает работать). Пример из С++: если объект одного класса посылает сообщение объекту второго класса, то посылающий класс сцеплен с принимающим классом. Если вы меняете интерфейс для принимающего класса, то вы также должны исследовать код в посылающем классе, чтобы убедиться в том, что он еще работает. Этот вид слабого сцепления безвреден. Вам нужно знать об отношениях сцепления для сопровождения программы, но без некоторого количества сцеплений программа не могла бы работать. Несмотря на это, для вас желательно по мере возможности минимизировать число отношений сцепления.
Эта минимизация обычно выполняется в С посредством модулей, а в С++ посредством классов. Функции в модуле (функции-члены в классе) сцеплены друг с другом, но за исключением нескольких интерфейсных функций (или объектов) они вовсе не сообщаются с внешним миром. В С вы должны использовать статический класс памяти, чтобы ограничить использование функции одним модулем. В С++ вы используете закрытые функции-члены.
Согласованность является противоположностью сцепления; сущности, которые группируются вместе (пункты диалогового и простого меню, функции в модуле, или члены класса), должны быть связаны по назначению. Отсутствие связности также является "сюрпризом". У текстового редактора, которым я пользуюсь, имеется в меню пункт "Настройка" и, кроме того, дополнительные опции настройки рассыпаны по четырем другим всплывающим меню. Я ожидал согласованной конфигурации и, когда не смог найти нужную мне опцию в пункте "Настройка", то решил, что этой опции просто нет. Эта плохо спроектированная система до сих пор доставляет беспокойство; после года пользования я по-прежнему не помню, где расположена каждая опция, и часто вынужден тратить раздражающие пять минут на поиск в пяти разных местах того, что хотел изменить. По отношению к исходному коду отсутствие согласованности заставляет вас делать то же самое - тратить свою жизнь на поиск объявлений функций в 15 различных файлах, что является очевидной проблемой при сопровождении.
2. Подавляйте демонов сложности (Часть 1).
Ричард Рашид (разработчик Mach - варианта ОС UNIX) выступил несколько лет назад с основным докладом на конференции разработчиков Microsoft. Его главный смысл состоял в том, что слишком большая сложность как в пользовательском интерфейсе, так и в программе является единственной большой проблемой, стоящей перед проектировщиками и пользователями программного обеспечения. По иронии, его речь была произнесена спустя два дня после провалившейся попытки показать нескольким тысячам очень толковых программистов, как программировать разработанный Microsoft интерфейс OLE 2.0 - один из самых сложных интерфейсов прикладного программирования, когда-либо мной виденных. (OLE означает "связь и внедрение объектов". Стандарт OLE 2.0 определяет интерфейс, который может использоваться двумя программами для взаимодействия между собой определенным образом. Это действительно объектная ориентация на уровне операционной системы).
Предыдущий оратор, который убеждал нас пользоваться библиотекой Microsoft Foundation Class (MFC), сказал нам, что поддержка OLE в MFC "включает 20000 строк кода, необходимых для каждого базового приложения OLE 2.0". Аудитория была ошеломлена не полезностью MFC, а тем фактом, что для написания базового приложения OLE 2.0 требуется 20000 строк кода. Любой интерфейс такой сложности таит в себе изъян. Следующие несколько правил используют OLE для показа характерных проблем, но не думайте, что проблема запутанности характерна лишь для Microsoft - она свойственна всей отрасли.
2.1. Не решайте проблем, которых не существует.
2.2. Решайте конкретную проблему, а не общий случай.
Поучительно использовать OLE 2.0 как пример того, что случается с многими слишком сложными проектами. Имеется две главные причины сложности интерфейса OLE. Во-первых, он безуспешно пытается быть независимым от языка программирования. Идея таблицы виртуальных функций С++ является центральной для OLE 2.0. Спецификация OLE даже пользуется нотацией классов С++ для документирования того, как должны работать различные интерфейсы OLE. Для реализации OLE на другом языке программирования (не С++) вы должны имитировать на этом языке таблицу виртуальных функций С++, что фактически ограничивает ваш выбор С++, С или языком ассемблера (если вы не разработчик компиляторов, который может добавить к выбранному вами языку нужные свойства). Если честно, то вы должны быть сумасшедшим, чтобы программировать OLE не на С++; потребуется гораздо меньше времени на изучение С++, чем на написание имитатора С++. То есть, эта идея независимости от языка программирования является неудачной. Интерфейс мог бы быть существенно упрощен за счет отказа от нее.
Возвращаясь к истории из предыдущего раздела, нужно заметить, что библиотека MFC в действительности решает проблему сложности, связанную с OLE, при помощи простого и легко понятного интерфейса, реализующего все возможности, нужные для большинства приложений OLE 2.0. Тот факт, что никто не хотел программировать с использованием OLE, пока для этого не появилась оболочка на основе MFC, впечатляет. Разработка хорошей оболочки вокруг плохого интерфейса не может быть решением лежащей в основе проблемы.
Если оболочка с использованием MFC столь проста, то почему лежащий в основе пласт так сложен? Ответ на этот вопрос является основным предметом проектирования. Создатели интерфейса OLE никогда не задавали себе два основных вопроса:
- Какие основные возможности должно поддерживать настоящее приложение?
- Как реализовать эти возможности простейшим способом?
Процесс объектно-ориентированного проектирования является в какой-то мере попыткой решения этой проблемы. Относительно просто добавить новую возможность в объектно-ориентированную систему или посредством наследования, или добавив новых обработчиков сообщений к существующим классам. Скрывая определения данных от пользователя класса, вы оставляете за собой право полностью менять внутреннюю организацию класса, включая определения данных, не беспокоя пользователей этого класса, при условии, что вы сохраняете его существующий интерфейс.
В структурном проектировании вы не стараетесь иметь такую роскошь. Вы обычно проектируете сперва структуры данных, и модификация структуры данных является главным делом, потому что нужно проверить каждую подпрограмму, использующую эту структуру данных, чтобы убедиться в том, что она еще работает. Как следствие, "структурные" программы склонны иметь много ничего не делающего кода. Это потому, что кто-нибудь может захотеть воспользоваться некой возможностью в будущем. На деле многие проектировщики структурных программ горды своей способностью предсказывать направление, в котором может развиваться программа. Все это приводит к большому объему ненужной работы и программам, имеющим больший размер, чем необходимо.
Вместо того, чтобы учитывать в проекте все возможные случаи, проектируйте свой код так, чтобы он мог быть легко расширен при необходимости добавления новых возможностей. Объектно-ориентированные проекты, как правило, тут работают лучше.
3. Интерфейс пользователя не должен быть похожим на компьютерную программу (принцип прозрачности).
Я однажды слышал, как кто-то сказал, что лучшим пользовательским интерфейсом из когда-либо разработанных является карандаш. Его назначение тотчас же понятно, для него не нужно руководство пользователя, он готовится к работе без особой суеты. Однако наиболее важным свойством является прозрачность. Когда вы пользуетесь карандашом, то думаете о том, что вы пишите, а не о самом карандаше.
Подобно карандашу, лучшими компьютерными интерфейсами являются те, которые скрывают сам факт того, что вы обращаетесь к компьютеру: замечательный пример - интерфейс с системой зажигания вашего автомобиля. Вы поворачиваете зажигание, включаете скорость и жмете на газ, как если бы все эти объекты интерфейса (ключ, рычаг скоростей, педаль) были прицеплены прямо на двигатель. Тем не менее, это не так: они теперь обычно просто устройства ввода в компьютер, который управляет двигателем.
К сожалению, подобный уровень ясности часто отсутствует в пользовательских интерфейсах. Представьте графический интерфейс пользователя Wimdows на автомобиле. Вы трогаетесь, выбрав в главном меню пункт "Движение автомобиля". Щелчок по нему откроет меню "Переключение скорости", которое предложит вам выбор из опций "Вперед", "Назад" и "Нейтральная". Щелкните по одной из них, чтобы передвинуть флажок на нужное вам направление. Затем вернитесь в меню "Движение автомобиля" и выберите команду "Поехали". Это вызовет появление диалогового окна "Скорость", где вы должны использовать ползунок для ввода желаемой скорости. Однако установить скорость правильно трудно вследствие высокого разрешения ползунка (пол-миллиметра движения мыши соответствует примерно 1 км/ч), поэтому вы скорее установите 59,7 км/ч вместо 60. Затем вы нажимаете кнопку "Поехали" в диалоговом окне, вслед за чем появляется сообщение "Стояночный тормоз не убран - нажмите F1 для справки" (динамик издает громкий звук). Вы покорно щелкаете по кнопке "ОК", чтобы убрать окно сообщений, затем снова пытаетесь открыть главное меню, но машина просто посылает вам звуковой сигнал. Наконец, поняв, что дело в том, что диалоговое окно "Скорость" еще отображается, вы щелкаете по кнопке "Отмена", чтобы убрать его. Вы открываете меню "Стояночный тормоз" и убираете флажок "Включен". Затем вы снова открываете окно "Поехали". И вновь получаете сообщение (и громкий звук) о том, что вы должны сначала выбрать направление в меню "Переключение скорости". В этот момент вы решаете, что вам, может быть, лучше пройтись на работу пешком.
Вот другой пример: Занимаясь недавно подготовкой обзора, я просмотрел несколько программ авиационных бортовых журналов. ("Бортовой журнал" - это очень простой табличный документ. Каждая строка соответствует отдельному вылету, а столбцы разбивают общую продолжительность вылета на различные категории: итоговая продолжительность, продолжительность полета в облаках и т.п.. В других столбцах полет помечается как деловой и так далее).
Самый лучший интерфейс из всех был тот, который выглядел совершенно одинаково с привычным бумажным журналом, но автоматизировал нудную работу. Вы вводили время в "итоговый" столбец - и то же самое время появлялось в других подходящих по смыслу столбцах. Значения по столбцам складывались автоматически для получения итогов по категориям. Вы могли легко генерировать необходимые отчеты и экспортировать данные в формат ASCII с разделителями из символов табуляции, который читается поистине любой программой электронных таблиц или подготовки текстов в мире. Для непривычного взгляда весь интерфейс казался, мягко говоря, разочаровывающим, но он был функциональным и интуитивно понятным, а программа - маленькой и быстрой. Однако самым важным было то, что этот интерфейс выглядел как бортовой журнал, а не как программа для Windows.
Другой крайностью был ошеломляющий графический интерфейс пользователя Windows: у него были диалоговые окна; у него была трехмерная графика; вы могли генерировать круговые диаграммы, показывающие процент продолжительности полета в облаках по отношению к вашему общему налету на "Цесне-172" за последние 17 лет; вы могли помещать внутрь отсканированную фотографию самолета...- вы представили эту картину. Программа выглядела превосходно, но ее было почти невозможно использовать. Не было практической причины для создания большинства диаграмм и отчетов, которые она могла генерировать. Ввод данных был неудобный и медленный - вы должны были вызвать диалоговое окно с полями, разбросанными по всей его поверхности. Фактически вы должны были прочитать все, чтобы обнаружить ту категорию, которая вас интересовала, а некоторые из категорий были скрыты за кнопками, неизбежно влеча за собой сложный поиск. Чтобы добавить обиду к оскорблению, эта программа была надстроена над сервером реляционной базы данных (помните, что это для поддержки простой таблицы без реляционных связей). Она заняла 30 Мбайт на моем диске. Мне требовалось почти 5 минут, чтобы сделать запись, которая занимала примерно 10 секунд в бумажном бортовом журнале или упомянутом ранее простом графическом интерфейсе пользователя. Программа была бесполезна, но, конечно, потрясающа.
Одна из главных проблем заключалась в том, что инструменты, использованные для создания второй программы, перегружают проектирование интерфейса. Все эти программы были разработаны на языке очень высокого уровня Visual Basic (который мне на самом деле не очень нравится, между прочим). Приложения, созданные при помощи таких построителей приложений, как Visual Basic (или Power Builder, или Delphi, или ...) обычно имеют специфический внешний вид, который немедленно говорит вам, что за инструмент был использован для построения этого приложения. Проектировщику интерфейса некуда обратиться за помощью, если этот специфический вид не подходит для конкретного проекта. Пользователи генераторов приложений должны иметь их несколько на выбор, чтобы затем использовать тот, который лучше всего соответствует потребностям данного интерфейса. Не смотря на это, мой опыт показывает, что наиболее практические программы со временем (в конце концов) должны перенести по меньшей мере часть кода интерфейса на язык низкого уровня типа С или С++, поэтому важно, чтобы ваш генератор приложений был способен также использовать низкоуровневый код.
4. Не путайте легкость в изучении с легкостью в использовании.
Эта проблема когда-то касалась почти исключительно машин Macintosh, но Windows и здесь в последнее время выходит вперед. Компьютер Mac был спроектирован так, чтобы прежде всего быть простым в освоении. Положим, что тетушка Матильда Мак-Гиликатти часто заходила в компьютерный магазин, чтобы пользоваться их услугой по моментальной печати кулинарных рецептов. В итоге Матильда забирает компьютер домой и успешно вводит рецепты в течение нескольких месяцев. Теперь она хочет взять эти рецепты, проанализировать их химический состав и написать статью в научный журнал о коллоидных свойствах продуктов питания на основе альбумина. Доктор Мак-Гиликатти - хорошая машинистка, печатающая обычно около 100 слов в минуту, но эта ужасная мышь ее постоянно тормозит. Каждый раз, когда ее руки отрываются от клавиатуры, она теряет несколько секунд. Она пытается найти слово в своем документе и обнаруживает, что для этого должна открыть меню, ввести текст в диалоговое окно и щелкнуть по нескольким экранным кнопкам. В конце файла она должна явно указать утилите поиска возвратиться к его началу. (Ее версия редактора vi 15-летней давности позволяет выполнить все это при помощи двух нажатий клавиш - без необходимости отрываться от клавиатуры). Наконец, она обнаруживает, что на выполнение обычной работы - подготовки статьи в журнал - уходит в два раза больше времени, чем раньше, в основном из-за проблем с пользовательским интерфейсом. Ей не понадобилось руководство, чтобы пользоваться этой программой, - ну и что?
Вернемся к примеру с карандашом из предыдущего параграфа. Очень трудно научиться пользоваться карандашом. У большинства детей это занимает несколько лет. (Вы могли бы возразить, что, судя по каракулям на рецептах, многие врачи этому так и не научились). С другой стороны, после того, как вы научились, карандашом пользоваться очень легко.
Главная проблема здесь состоит в том, что для опытного пользователя часто требуется совершенно другой интерфейс, чем для начинающего. Дополнительная помощь типа "горячих" клавиш не решает эту проблему; старый неуклюжий интерфейс пользователя все еще мешает продуктивности, и нет особой разницы: откроете ли вы меню при помощи "горячей" клавиши, или мышью. Здесь проблема в самом меню.
5. Производительность может измеряться числом нажатий клавиш.
Интерфейс, требующий меньше нажатий клавиш (или других действий пользователя типа щелчков мышью), лучше того, который требует много нажатий для выполнения одной и той же операции, даже если такие виды интерфейсов обычно сложнее в освоении.
Подобным образом пользовательскими интерфейсами, скрывающими информацию в меню или за экранными кнопками, обыкновенно труднее пользоваться, потому что для выполнения одной задачи необходимо выполнить несколько операций (вызвав подряд несколько спускающихся меню). Хороший пример - настройка программы. Во многих из используемых мной ежедневно программ опции настройки рассыпаны по нескольким меню. То есть для вызова диалогового окна, настраивающего один из аспектов того, что делает программа (например, выбор шрифта), я должен выбрать одно меню. Затем я должен вызвать другое меню, чтобы сделать что-то в том же духе (например, выбрать цвет). Лучше поместить все опции настройки на одном экране и использовать форматирование экрана для объединения опций по назначению.
6. Если вы не можете сказать это по-английски, то вы не сможете выполнить это на С/С++.
Это правило с последующим также относятся к правилам пользовательского интерфейса, но здесь под "пользователем" уже понимается программист, использующий написанный вами код - часто это вы сами.
Акт записи на английском языке описания того, что делает программа, и что делает каждая функция в программе, является критическим шагом в мыслительном процессе. Хорошо построенное, грамматически правильное предложение - признак ясного мышления. Если вы не можете это записать, то велика вероятность того, что вы не полностью продумали проблему или решение. Плохая грамматика и строение предложения являются также показателем небрежного мышления. Поэтому первый шаг в написании любой программы - записать то, что делает программа, и как она это делает.
Есть разные мнения о возможности мышления вне языка, но я убежден, что аналитическое мышление того типа, который нужен в компьютерном программировании, тесно связано с языковыми навыками. Я не думаю, что является случайностью то, что многие из знакомых мне лучших программистов имеют дипломы по истории, филологии и схожим наукам. Также не является совпадением то, что некоторые из виденных мной худших программ были написаны инженерами, физиками и математиками, затратившими в университете массу энергии на то, чтобы держаться как можно дальше от занятий по языку и литературе.
Сущность заключается в том, что математическая подготовка почти не нужна в компьютерном программировании. Тот тип организационного мастерства и аналитических способностей, который нужен для программирования, связан полностью с гуманитарными науками. Логика, например, преподавалась на философском факультете, когда я был в университете. Процесс, используемый при проектировании и написании компьютерных программ, почти полностью идентичен тому, который используется, чтобы сочинять и писать книги. Процесс программирования совсем не связан с теми процессами, которые используются для решения математических уравнений.
Здесь я делаю различие между информатикой (computer science) - математическим анализом компьютерных программ - и программированием или разработкой программного обеспечения - дисциплиной, интересующейся написанием компьютерных программ. Программирование требует организационных способностей и языковой подготовки, а не абстрактного мышления, необходимого для занятий математическим анализом. (В университете меня заставили проходить год на лекции по математическому анализу, но я никогда из него ничего не использовал ни на занятиях по информатике, хотя для них матанализ был необходимым условием, ни в реальной жизни).
Я как-то получил открытую рецензию на книгу, посвященную мной предмету проектирования компиляторов, в которой рецензент (который преподавал в одном из ведущих университетов) заявил, что он "считает абсолютно неуместным включение исходного кода компилятора в книгу о проектировании компиляторов". По его мнению, необходимо учить "фундаментальным принципам" - лежащей в основе математике и теории языка, а детали реализации - "тривиальны". Первое замечание имеет смысл, если у вас создалось впечатление, что книга написана ученым-специалистом по информатике, а не программистом. Рецензент интересовался лишь анализом компилятора, а не тем как его написать. Второе замечание просто показывает вам, насколько изолировала себя научная элита от реального труда программирования. Интересно, что основополагающая работа по теории языка, сделавшая возможным написание компиляторов, была выполнена в Массачусетском технологическом институте лингвистом Наумом Хомским, а не математиком.
Обратной стороной этой монеты является то, что если вы зашли в тупик при решении проблемы, один из лучших способов выйти из него - это объяснить проблему приятелю. Почти всегда решение возникает в вашей голове посредине объяснения.
6.1. Начинайте с комментариев.
Если вы последовали совету в предыдущем правиле, то комментарии для вашей программы уже готовы. Для того, чтобы получить документированное описание реализации, вы просто писали и добавляли вслед за каждым абзацем блоки кода, реализующие качества, описанные в этом абзаце. Оправдание "у меня не было времени, чтобы добавить комментарии" на самом деле означает "я писал этот код без проекта системы и у меня нет времени воспроизвести его". Если создатель программы не может воспроизвести проект, то кто же сможет?
7. Читайте код.
Все писатели - это читатели. Вы учитесь, когда смотрите, что делают другие писатели. Удивительно, но программисты - писатели на С++ и С - часто не читают код. Тем хуже. Я настоятельно рекомендую, чтобы, как минимум, члены группы программирования читали код друг друга. Читатель может найти ошибки, которые вы не увидели, и подать мысль, как улучшить код.
Идея здесь - не формальная "критика кода", имеющая довольно сомнительный характер: никто не хочет наступать на ногу коллеге, поэтому шансы получить полезную обратную связь в формальной ситуации малы. Для вас лучше присесть с коллегой и просто разобрать код строка за строкой, объясняя что как делается и получая какую-то обратную связь и совет. Для того, чтобы подобное упражнение принесло пользу, автор кода не должен делать никаких предварительных пояснений. Читатель должен быть способен понимать код, читая его. (Нам всем приходилось иметь дело с учебниками, столь трудными для понимания, что ничего нельзя было понять без объяснения преподавателя. Хотя это и гарантирует, что преподаватель не останется без работы, но никак не отражается на авторе учебника). Если вам пришлось объяснять что-то вашему читателю, то это значит, что ваше объяснение должно быть в коде в качестве комментария. Добавьте этот комментарий, как только вы его произнесли; не откладывайте этого до окончания просмотра.
7.1. В цехе современных программистов нет места примадоннам.
Это следствие из правила чтения. Программисты, которые думают, что их код совершенен, которые отвергают критику, вместо того, чтобы считать ее полезной, и которые настаивают на том, что они должны работать втихомолку, вероятно, пишут тарабарщину, не поддающуюся сопровождению - даже если кажется, что она работает. (Смысловое ударение здесь на слове кажется).
8. Разлагайте сложные проблемы на задачи меньшего размера.
На самом деле это также правило и литературного стиля. Если концепцию слишком сложно объяснить за один раз, то разбейте ее на меньшие части и объясняйте каждую по очереди. То же назначение у глав в книге и параграфов в главе.
Как пример, связанный с программированием, возьмем прошитое бинарное дерево, отличающееся от нормального дерева тем, что указатель на узел-потомок в концевом узле указывает на само дерево. Действительным преимуществом прошитого дерева является то, что его легко пересечь нерекурсивно при помощи этих дополнительных указателей. Проблема заключается в том, что сложно выйти из алгоритмов пересечения (в особенности обратного пересечения). С другой стороны, имея указатель на узел, легко написать алгоритм поиска последующего элемента в обратном порядке. Путем изменения формулировки с "выполнить пересечение в обратном порядке" на "начав с самого отдаленного узла, искать последующие элементы в обратном порядке, пока они не закончатся" получаем разрешимую задачу:
tree t; // деревоnode = postorder_first( t ); // исходный узел
while( node ) // есть еще узлы?
node = postorder_successor( t ); // следующий узел-родитель
9. Используйте весь язык.
9.1. Используйте для работы соответствующий инструмент.
Данное правило является спутником правила "Не путайте привычность с читаемостью", представленного ниже, но скорее больше касается проблем руководства. Мне часто говорят, что студентам не разрешается использовать некоторые части С или С++ (обычно это указатели), потому что они "нечитаемы". Обычно это правило навязывается руководителями, знающими ФОРТРАН, БЕЙСИК или какой-то другой язык, не поддерживающий указатели, ибо их не очень то заставишь изучать С. Вместо того, чтобы допустить, что их знания недостаточны, такие руководители будут лучше калечить своих программистов. Указатели отлично читаемы для программистов на С.
И наоборот, я видел ситуации, где руководство требовало, чтобы программисты перешли с языка программирования типа КОБОЛ на С, но не желало оплачивать переподготовку, необходимую для перехода. Или хуже, руководство платило за переподготовку, но не предоставляло времени, необходимого для действительного изучения материала. Переподготовка является занятием, требующим всего рабочего дня. Вы не можете одновременно выполнять "полезную" работу, а если попытаетесь, то ваши деньги будут выброшены на ветер. Так или иначе, после того, как руководители видят, что их штаб не был превращен в гуру программирования на С++ после 3-дневного краткого курса, они реагируют, накладывая ограничения на использование некоторых частей языка. Фактически говоря "Вы не можете использовать ту часть С++, которая не похожа на язык, который мы использовали до перехода на С++". Естественно, что будет нельзя эксплуатировать ни одну из прогрессивных особенностей языка - которые прежде всего и являются главной причиной его использования - если вы ограничите себя "простейшим" подмножеством особенностей.
Глядя на эти ограничения, мне в первую очередь интересно знать, зачем было менять КОБОЛ на С. Принуждение программистов на языке КОБОЛ использовать С всегда поражало меня своей большой глупостью. КОБОЛ - великолепный язык для работы с базами данных. У него есть встроенные примитивы, упрощающие выполнение задач, которые довольно трудны для С. С, в конце концов, был разработан для создания операционных систем, а не приложений баз данных. Довольно просто дополнить КОБОЛ, чтобы он поддерживал модный графический интерфейс пользователя, если это единственная причина перехода на С.
10. Проблема должна быть хорошо продумана перед тем, как она сможет быть решена.
Это правило с двумя последующими первоначально располагалось в начале этой главы. Подумав, я переместил их сюда, так как побоялся, что, прочитав их, вы пропустите оставшуюся часть главы. Однако в мои намерения не входит чтение проповедей. Эти правила посвящены весьма реальным проблемам и во многих отношениях являются самыми важными правилами в этой книге.
Настоящее правило является настолько очевидным утверждением в повседневной жизни, что кажется странным его восприятие как едва ли не ереси применительно к программированию. Мне часто говорят, что "невозможно потратить пять месяцев на проектирование, не написав ни одной строки кода - ведь наша производительность измеряется числом строк кода, написанных за день". Люди, говорящее это, обычно знают, как делается хороший проект; просто у них нет этой "роскоши".
Мой опыт говорит, что хорошо спроектированная программа не только работает лучше (или просто работает), но и может быть написана быстрее и быть проще в сопровождении, чем плохо спроектированная. Лишние четыре месяца при проектировании могут сэкономить вам более четырех месяцев на этапе реализации и буквально годы в период сопровождения. Вам не добиться высокой производительности, если приходится выбрасывать прошлогоднюю работу из-за существенных изъянов проекта.
Кроме того, скверно спроектированные программы труднее реализовать. Тот аргумент, что у вас нет времени на проектирование, потому что вы "должны захватить рынок программ как можно скорее", просто не выдерживает никакой критики, потому что реализация плохого (или никакого) проекта требует гораздо больше времени.
11. Компьютерное программирование является индустрией обслуживания.
Меня иногда шокирует неуважение, проявляемое некоторыми программистами по отношению к пользователям своих программ, как если бы "пользователь" (произносится с презрительной усмешкой) был низшей формой жизни, неспособной к познавательной деятельности. Но факт состоит в том, что весь компьютер существует лишь с одной целью: служить конечному пользователю наших продуктов. Если никто бы не пользовался компьютерными программами, то не было бы программистов.
Печальным фактом является то, что существенно больше половины разрабатываемого ежегодно кода выбрасывается за ненадобностью. Такие программы или никогда не поступают в эксплуатацию, или используются лишь очень короткое время, после чего выбрасываются. Это означает невероятную потерю производительности, сокращая для большинства управляющих реальные среднесуточные цифры выработки. Подумайте о всех начинающих фирмах, выпускающих программы, которые никогда не будут проданы, о всех внутрифирменных группах разработчиков, пишущих бухгалтерские пакеты, которыми нельзя воспользоваться.
Легко увидеть, как возникает эта печальная ситуация: программисты создают программы, которые никому не нужны. Исправить ее тоже легко, хотя это и сталкивается с неожиданными трудностями в некоторых условиях: спросите людей, что им нужно, и затем сделайте то, что они вам сказали.
К сожалению, многие программисты производят впечатление полагающих, что конечные пользователи не знают чего хотят. Вздор. Почти всегда пользователи оказываются так запуганы сыплющим специальными терминами "экспертом", что замолкают. Мне часто говорили: "Я знаю, что мне нужно, но не могу это выразить". Лучший ответ на это: "Отлично, скажите это на нормальном языке - я сделаю перевод на компьютерный".
12. Вовлекайте пользователей в процесс проектирования.
13. Заказчик всегда прав.
Ни одной программе не добиться успеха, если ее проектировщики не общаются непосредственно с ее конечными пользователями. Несмотря на это, часто ситуация больше напоминает игру ("испорченный телефон"), в которую многие из нас играли в детском саду и при которой 20 ребятишек садятся в кружок. Кто-нибудь шепчет фразу своему соседу (соседке), который передает ее своему, и так далее по кругу. Забава заключается в том, чтобы послушать как сообщение звучит после того, как пройдет весь круг - обычно ничего похожего на исходную фразу. Тот же самый процесс часто встречается при разработке программ. Пользователь говорит с управляющим, докладывающим другому управляющему, который нанимает консультационную фирму. Президент консультационной фирмы разговаривает с руководителем разработчиков, который в свою очередь говорит со старшим группы, обращающимся наконец к программистам. Шансы на то, что даже простой документ с требованиями останется после этого процесса невредимым, равны нулю. Единственным решением этой проблемы является тесное вовлечение пользователей в процесс разработки, лучше всего путем включения по крайней мере одного конечного пользователя в команду разработчиков.
Родственная ситуация складывается в случае простой самонадеянности части программистов, которые говорят: "Я знаю, что пользователи сказали, что им нужно сделать это таким способом, но у них нет достаточных знаний о компьютерах, чтобы принять сознательное решение; мой способ лучше". Такое отношение фактически гарантирует, что программой никогда не будут пользоваться. Исправить ситуацию здесь можно, официально назначив конечного пользователя лицом, оценивающим качество проекта. Никто не может начать писать код до тех пор, пока пользователь-член команды не даст на это добро. Сотрудники, игнорирующие проект в пользу своих идей, должны быть уволены. В реальной жизни для подобного типа детского упрямства на самом деле нет места.
При этом нужно сказать, что опытный проектировщик зачастую предлагает лучшее решение проблемы, чем то, что придумано конечным пользователем, в особенности если учесть, что конечные пользователи часто предлагают интерфейсы, созданные по образцу программ, которыми они постоянно пользуются. Несмотря на это, вы должны убедить пользователя, что ваш способ лучше, перед тем, как его реализовать. "Лучший" интерфейс не является лучшим, если никто, кроме вас, не сможет (или не захочет) им пользоваться.
14. Малое - это прекрасно. (Большое == медленное)
Распухание программ является огромной проблемой. Жесткий диск вместимостью 350 Мбайт на моем лаптопе может вместить операционную систему, усеченные версии моих компилятора и редактора и больше ничего. В стародавние времена я мог разместить версии для CP/M тех же программ на единственной дискете вместимостью 1,2 Мбайта. UNIX в то время спокойно работал на 16-разрядном PDP-11 c 64 Кбайтами ядра (внутренней памяти). В наше время большинство операционных систем требуют 32-разрядных машин с минимум 16 Мбайтами оперативной памяти, чтобы работать с приемлемой скоростью. Я убежден, что большая часть этого распухания памяти является результатом небрежного программирования.
В добавок к проблеме размера у вас также есть проблема с временем выполнения. Виртуальная память не является настоящей памятью. Если ваша программа слишком велика, чтобы поместиться в оперативной памяти, или если она выполняется одновременно с другими программами, то она должна периодически подкачиваться с диска. На эти подкачки, мягко выражаясь, расходуется время. Чем меньше программа, тем менее вероятно, что произойдет подкачка, и тем быстрее она будет выполняться.
Третьей проблемой является модульность. Одна из основ философии UNIX гласит "меньше - лучше". Большие задачи лучше выполняются взаимодействующей системой маленьких модульных программ, каждая из которых делает хорошо лишь одно задание, но каждая из них может сообщаться с другими компонентами. (Стандарт связи и внедрения объектов Microsoft (OLE) добавляет это свойство в Windows, а OpenDoc - в Macintosh). Если ваше приложение представляет собой модульную конструкцию из маленьких программ, работающих вместе, то становится очень просто настраивать вашу программу по заказу путем смены модулей. Если вам не нравится этот редактор, то поменяйте его на новый.
Наконец, программы обычно уменьшаются в процессе усовершенствования. Большие программы, вероятно, никогда не подвергались усовершенствованиям.
Разыскивая решение этой проблемы, я заметил, что коллективы программистов с плохим руководством часто создают излишне большие программы. То есть группа ковбоев от программирования, каждый из которых работает в одиночку в своем оффисе и не разговаривает друг с другом, напишет массу лишнего кода. Вместо одной версии простой служебной функции, используемой по всей системе, каждый программист создаст свою версию одной и той же функции.
Глава 2. Общие проблемы разработки программ
Эта часть книги содержит общие правила для процесса разработки программ и не касается деталей собственно языков С и С++. Я сделаю это в последующих частях.
15. Прежде всего, не навреди.
Это правило касается сопровождения программ. Будучи ребенком, я читал научно-фантастический рассказ, в котором незадачливый путешественник во времени случайно наступает на доисторическую бабочку и, вернувшись в свое время, находит окружающий мир изменившимся ужасным образом. Это похоже на большие компьютерные программы, где тронь здесь что-то кажущееся незначительным - и где-то там вся программа перестает работать. Методы объектно-ориентированного проектирования существуют прежде всего для решения (или по крайней мере для облегчения решения) этой проблемы в будущем, но уже существуют миллионы строк старого кода, который сегодня нуждается в сопровождении.
Мне приходилось видеть людей, которые изменяют программу просто потому, что им не нравится, как она выглядит. Это не очень хорошая идея. Если вы не знаете всех частей программы, затрагиваемых изменением (а это почти невозможно), то не трогайте код. Вы можете вполне резонно возразить, что на самом деле ни одно из правил в этой книге не относится к сопровождению программ. Вы просто не можете менять существующий код в соответствии с каким-то методическом руководством (как бы вам этого не хотелось), не вызывая риска непоправимого вреда. Представленные здесь правила полезны лишь в том случае, когда вы начинаете программу с нуля.
16. Редактируйте свою программу.
17. Программа должна быть переписана не менее двух раз.
18. Нельзя измерять свою производительность числом строк.
Прежде, когда вы изучали английский в школе, то вам никогда не приходило в голову сдавать черновик письменного задания, если вы, конечно, рассчитывали на оценку выше тройки. Тем не менее, многие компьютерные программы являются просто черновиками и содержат столько же ошибок, сколько и черновики ваших сочинений. Все хорошие программы вначале написаны, а затем отредактированы с целью улучшения. (Конечно, я имею ввиду "редактировать" в смысле "исправлять".)
Имейте в виду, что редактирование должно быть сделано по окончании, потому что неотредактированный текст программы по сути невозможно сопровождать (точно также, как и ваше неотредактированное сочинение было невозможно читать). Создатели этой программы знакомы с ее текстом и могут выполнить редактирование более эффективно, чем программист, занимающийся сопровождением, который сначала должен ее расшифровать перед тем, как выполнить какую-либо реальную работу.
К сожалению, это очень похоже на театральное шоу, когда кто-то пишет программу быстро, но не думая о сопровождении или о элегантности. "Ого, она выдает в два раза больше кода вдвое быстрее". Учтите, что тот же бедный сопровождающий программист будет затем вынужден затратить в восемь раз больше времени, сокращая первоначальный размер программы наполовину и делая ее пригодной для использования. Число строк кода в день, как мера объема, не является мерилом производительности.
Если вам нужен другой, чем сопровождение, мотив, то имейте в виду, что редактирование может рассматриваться как процесс уменьшения чего-либо. Маленькие программы выполняются быстрее.
19. Вы не можете программировать в изоляции.
Классическая книга Джеральда Уэйнберга The Psychology of Computer Programming (New York, Van Nostrand Reinhold, 1971) содержит великолепную историю о автоматах с газированной водой. Администрация одного вычислительного центра решила, что слишком много времени растрачивается сотрудниками у автоматов с газированной водой. Люди создают много шума и ничего при этом не делают, поэтому автоматы убрали. Через несколько дней консультанты на местах были настолько перегружены работой, что к ним стало невозможно обратиться. Мораль состоит в том, что люди совсем не зря растрачивали время: оказывается, издавая весь этот шум, они помогали друг другу в решении проблем.
Изоляция может стать настоящей проблемой в группе объектно-ориентированного проектирования, которая по необходимости должна состоять из пользователей, проектировщиков, программистов, специалистов по документации и т.д., работающих совместно. Так как число программистов в этой группе часто меньше, чем в более традиционных проектных коллективах, то становится трудно найти кого-то, с кем можно обсудить проблемы; страдает производительность. Подумайте о еженедельных вечеринках в вашей фирме, как средстве повышения производительности.
20. Пустые потери времени.
Если вы не можете решить неподатливую проблему, то займитесь на некоторое время чем-либо другим. Программисты часто наиболее продуктивны, когда смотрят в окно, слоняются по коридорам с пустым выражением на своих лицах, сидят в кафе и пьют кофе с молоком, или иным способом "теряют время".
Я был студентом в те древние времена, когда персональным компьютером был Apple I, а серьезные студенты-программисты владели коробками S-100, которые вы программировали, вводя двоичные команды переключателями лицевой панели по одному байту за раз. (Если вы были счастливчик, то имели интерпретатор языка BASIC и терминал, сделанный из старого телевизора). Студенты делили PDP 11/70, работавшую под UNIX (которая отлично работала на 16-битовой машине с 64 Кбайт памяти - Боже! Как все с тех пор усовершенствовалось). О возможности использования персонального компьютера для выполнения домашних заданий не было и речи.
На среднем занятии по программированию присутствовало от 40 до 80 человек, и одновременно проводилось шесть и более занятий. Поэтому, когда на занятии раздавалось задание, то вы хватали бумагу с ним и буквально опрометью бросались вниз в терминальный зал, где приковывали себя к компьютеру и начинали яростно программировать до тех пор, пока не выполняли свое задание. Это могло продолжаться несколько дней. Если вы отрывались поесть или поспать, то ваш терминал занимал другой, и у вас появлялась весьма реальная перспектива не уложиться в срок, отведенный на задание. Некоторые люди все еще продолжают программировать подобным способом.
Такая обстановка, конечно, не способствовала хорошо продуманному проектированию программ, поэтому большинство из этих программ были в четыре раза больше, чем необходимо, и требовали в два раза больше времени на отладку, чем требовалось. К тому же, количество строк кода, написанное за час, сокращается пропорционально количеству часов, которые вы просидели, глядя на экран. (Это иллюзия - думать, что вы можете достичь большей производительности, работая 12 часов в день вместо 8).
Однажды, будучи на последнем курсе, я был так расстроен, пытаясь решить одну проблему, о которую бился головой в течение примерно четырех часов, что с чувством отвращения завершил сеанс и выскочил на улицу. Примерно три минуты спустя, когда я спускался по холму за порцией сосисок, искомое решение неожиданно всплыло в моей голове. Это было настоящим откровением: вы должны расслабиться, чтобы дать своему мозгу возможность работать. К сожалению, я не смог пробиться назад к компьютеру, поэтому я так никогда и не исправил свою ошибку, но, по крайней мере, понял, как должен работать этот процесс.
21. Пишите программу с учетом сопровождения - вы специалист по сопровождению.
Сопровождение начинается немедленно после завершения программы, а сопровождением на этой стадии обычно занимаетесь вы сами. Это хорошая мысль - осчастливить сопровождающего программиста. Поэтому ваша первая забота о том, чтобы программа легко читалась. Структура и назначение каждой строки должны быть избыточно ясны, и если это не так, то вам нужно добавить поясняющие комментарии.
Одной из причин того, что поиски математических доказательств корректности программ остаются донкихотством, заключается в том, что нет программ без ошибок. Каждая программа не только содержит ошибки, но и требования к ней меняются, как только программа начинает эксплуатироваться, и у пользователя появляются потребность в каких-то новых свойствах, что вызывает появление новых и усовершенствованных ошибок. Так как ошибки всегда с нами, то мы должны писать нашу программу так, чтобы их можно было легче искать.
Вы можете переформулировать настоящее правило таким образом: Не умничайте. Искусный код почти невозможно сопровождать.
21.1. Эффективность часто просто пугало.
Я потратил несколько часов, делая одну подпрограмму более "эффективной", и не останавливался, чтобы подумать о том, как часто эта подпрограмма будет вызываться, что является пустой потерей времени в том случае, когда программа вызывается лишь один или два раза. Ваша программа должна быть непременно настолько эффективной, насколько это возможно, но вашей первоочередной заботой является сопровождение, и вы не должны приносить читаемость в жертву на алтарь эффективности. Напишите программу сперва с учетом сопровождения, затем запустите профайлер для своей программы и определите, где на самом деле есть узкие места. Будучи вооружены реальной информацией, вы теперь знаете, где стоит обменять часть читаемости на скорость, и можете вернуться и сделать это изменение. Тем не менее, вы можете включить первоначальный текст в комментарий, чтобы не потерять его. Всегда имейте в виду, что любое количество подчисток на уровне текста программы не повысит эффективность так, как это сделает лучший алгоритм. Пузырьковая сортировка будет выполняться медленно вне зависимости от того, насколько хорошо она запрограммирована.
Глава 3. Форматирование и документация
Форматирование важно; тексты на С и С++ и так достаточно тяжело читаются, чтобы ухудшать ситуацию еще и плохим форматированием. Представьте, что вы пытаетесь прочесть книгу, текст которой не отформатирован: нет абзацных отступов, разделений абзацев пустой строкой, пробелов после знаков препинания и так далее. Сопровождение плохо отформатированной программы невозможно.Я объединил правила форматирования и документации в одной части, потому что форматирование является одним из лучших инструментов документирования, имеющихся в вашем распоряжении. Под "документацией", рассматривающейся в этой части книги, понимается документирование программ (т.е. комментарии, а не документация уровня пользователя). Его зря не относят к программированию, ведь хороший комментарий для вас - в буквальном смысле нить Ариадны.
Я сознаю, что дискуссии по вопросам форматирования и документации часто достигают религиозного накала. Имейте в виду, что приводимые здесь мной правила - только те, которыми я пользуюсь сам. Имеются и другие совершенно разумные методы работы. С другой стороны, кто-то не особо умный мне однажды сказал, что "не важно, какой стиль форматирования вы применяете, если вы применяете его постоянно". Программа, которая постоянно форматируется плохо, хуже, чем понятная временами. Случайный просвет лучше, чем никакого.
22. Программа без комментариев ничего не стоит.
Программа, на написание которой затрачен год, может использоваться в течение 10 лет. Вам придется затратить на сопровождение гораздо больше денег, чем вы выделили на первоначальную разработку, а программа без комментариев несопровождаема. "Блестящий" программист, который втрое быстрее, чем другие, пишет короткий, элегантный, но некомментированный текст программы, вам обойдется дорого. Какому-то менее талантливому программисту придется затратить в 10 раз больше времени, чем нужно, устраняя неизбежные ошибки.
Программисты, которые не могут писать по-английски (или на том языке, на котором говорят в стране, где предполагается осуществлять сопровождение), изготовляют часовые бомбы, а не компьютерные программы. Так как хорошая документация столь необходима для процесса сопровождения, то важно, чтобы программисты были способны ее написать. По этой причине начинающие программисты, имеющие диплом по филологии, истории или другой гуманитарной дисциплине, часто являются более предпочтительными, чем люди с дипломами по естественным наукам (математике, физике и т.п.). Специалисты по естественным наукам редко знают как писать, а большинство из них также не знают как программировать; они обучены тому, как запрограммировать алгоритм, а не как написать пригодную для сопровождения компьютерную программу.
К счастью, писать можно легко научиться. Конечно, если вы придерживаетесь правила "Сделай сначала комментарии", то вам придется писать все свои комментарии до начала программирования.
23. Располагайте программу и документацию вместе.
Если документация отделена от текста программы, то ее очень трудно обновлять. Следовательно, основная часть вашей документации должна располагаться в комментариях, а не в отдельном документе.
Если вам на самом деле нужна отпечатанная документация высшего качества, то вы можете воспользоваться чем-нибудь похожим на систему Web (для языка Паскаль) или CWeb (для языков С и С++) в комбинации с TeX. Я пользуюсь подобной системой под названием arachne, которая была разработана мной для того, чтобы писать свою книгу Compiler Design in C. (Arachne документирует тексты на С и С++, используя в качестве редактора troff). Все эти программы позволяют вам размещать исходный текст программы и документацию в одном файле. Вы можете выделить исходный текст для компиляции, или загрузить этот файл в текстовый процессор, чтобы напечатать единое руководство с исходным текстом и документацией. Эти системы позволяют осуществлять перекрестный поиск идентификаторов в программе и документации, позволяя вам прослеживать связи одной части программы с другой ("этот код используется вон там"), и так далее. Так как для получения печатной версии используется обычный текстовый процессор, то вы можете делать то, чего непросто добиться в комментариях - вставлять рисунки, например.
24. Комментарии должны быть предложениями.
Они должны быть хорошо составлены и иметь правильную пунктуацию, по возможности без сокращений. Не превращайте свои комментарии в секретный код, применяя странные сокращения и изобретая свой собственный грамматический строй. Вам также не должна требоваться нить Ариадны для расшифровки комментариев.
25. Пропустите свой исходный тест через систему проверки орфографии.
Ваши комментарии не только станут более читаемыми, этот метод побудит вас использовать в качестве имен переменных тех, которые легко читаются, потому что они являются обычными словами.
26. Комментарий не должен подтверждать очевидное.
Начинающие программировать на С склонны попадать в эту ловушку. Избегайте явно нелепых случаев типа:
++x; // увеличить xно мне также не нравятся комментарии типа: /*-------------------------------------------* Определения глобальных переменных:
*-------------------------------------------
*/
Любой средний программист знает, как выглядит определение.
27. Комментарий должен предоставлять только нужную для сопровождения информацию.
Особенно неприятным и бесполезным комментарием является декларативный заголовочный блок. Заголовок сам по себе не является злом, а совсем наоборот. Блок комментариев в начале файла, описывающий что делается в файле, может быть довольно полезен. Хороший блок говорит вам, какое свойство реализуется файлом, показывает список открытых (не статических) функций, сообщает вам, что эти функции делают и т.д.
Заголовки, которые мне не нравятся, имеют содержание, которое определяется указанием, обычно типа какого-то руководства по фирменному стилю. Такие заголовки обычно выглядят подобно листингу 1, увеличивая беспорядок посредством обильных количеств бесполезной информации за счет читаемости. Часто случается так, как на листинге 1, когда заголовок существенно больше самой программы. Также обычно, как в нашем случае, что текст программы или совершенно самодокументирован, или нужно добавить одну или две строки комментариев, чтобы он им стал. Хотя требование вышеуказанной бессмыслицы и может согревать душу деспота-руководителя, но для облегчения сопровождения оно мало что дает.
Листинг 1. Бесполезный заголовочный комментарий.
| ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | ** |
| | |
| | |
| | |
| | |
| | |
28. Комментарии должны быть в блоках.
Комментарии в общем воспринимаются лучше, когда помещаются в многострочных блоках, которые чередуются с блоками текста программы. Для этого комментарий должен описывать на высоком уровне, что делают несколько последующих строк кода. Если комментарии попадаются через строчку, то это похоже на чтение двух книг одновременно, причем по строке из каждой по очереди. И если программа, комментируемая вами, сложная, то вы можете воспользоваться сносками:
// Вот блочный комментарий, описывающий последующий блок программы.// После общего резюме я описываю некоторые особенности:
//
// 1. Этот комментарий описывает, что происходит в строке с меткой 1
//
// 2. Этот комментарий описывает, что происходит в строке с меткой 2
//
// В точке 1 алгоритм устанавливается на ...
//
here_is_the_code();
while ( some_condition )
{
this_code_is_rather_obscure(); /* 1 */}more_stuff_here();
while ( some_condition )
{
this_code_is_also_obscure(); /* 2 */}
29. Комментарии должны быть выровнены вертикально.
Выравнивайте начало и конец комментария вертикально в многострочных комментариях.
/* Первая строка,* вторая строка,
* третья строка.
*/
Если ваш компилятор их поддерживает, то здесь помогут комментарии в стиле С++: // Первая строка,// вторая строка,
// третья строка.
Есть две причины появления этого правила, они обе демонстрируются в последующей программе:/**********************************************************
void the_function( void )
Это многострочный комментарий, выполняющий все, что должен делать комментарий.К сожалению, отсутствие слева вертикального столбца из звездочек затрудняет зрительное разделение комментария и программы
***********************************************************void the_function( void )
{
// далее настоящая функция.code_goes_here(); }
/*********************************************************/Во-первых, заметили ли вы, что я забыл поместить / в конце второй строки звездочек? Таким путем можно запросто терять целые функции. Во-вторых, трудно заметить, где оканчивается комментарий и начинается текст программы. Исправьте обе ошибки следующим образом:
/*********************************************************** void the_function( void )
*
* Это многострочный комментарий, выполняющий все, что должен
* делать комментарий.
*
* Вертикальный столбец из звездочек слева облегчает
* зрительное разделение комментария и программы
* *********************************************************** */
void the_function( void )
{
// далее настоящая функция.
code_goes_here();
}
30. Используйте аккуратные столбцы везде, где можно.
Так как форматирование по сути является видом комментирования, то это правило применяйте также и к тексту программы. Два следующих блока функционально одинаковы, но заметьте, насколько легче искать имена переменных во втором блоке, причем не из-за выравнивания комментариев, а потому что имена образовали аккуратный столбец:
int x; // Опишите, что делает x.unsigned long int (*pfi)(); // Опишите, что делает pfi.
const char *the_variable; // Опишите, что делает the_variable.
int z; // Опишите, что делает z.
x = 10; // Здесь идет комментарий.
the_variable = x; // Здесь второй комментарий.
z = x; // A здесь третий.
по сравнению с:| int | x; | // Опишите, что делает x. |
| unsigned long int | (*pfi)(); | // Опишите, что делает pfi. |
| int | z; | // Опишите, что делает z. |
| const char | *the_variable; | // Опишите, что делает the_variable. |
| x | = 10; | // Здесь идет комментарий. |
| the_variable | = x; | // Здесь второй комментарий. |
| z | = x; | // A здесь третий. |
Другим хорошим местом для использования столбцов является список инициализации элементов в С++, который я форматирую следующим образом:
class derived : public base{
string str;const int x;
public: derived( char *init_str, int init_x ) {}}derived::derived( char *init_str, int init_x )
:base( str, x ),str ( init_str )
,x ( init_x )
{}
31. Не располагайте комментариев между именем функции и открывающей скобкой.
Основная сложность в следующем примере:
foo( int x )/* Не помещайте
* комментарий
*/ здесь.
{//...}
заключается в том, что тело функции может оканчиваться на следующей странице или не помещаться на одном экране. То есть читающий не может сказать, видит ли он прототип или действительное определение. Поместите этот комментарий или до имени функции, или вставьте его в тело функции ниже открывающей скобки: /* Или помещайте** его здесь.
*/
foo( int x )
{
/* или здесь,** с таким же отступом, что и программа.
*/
}
32. Помечайте конец длинного составного оператора чем-нибудь, имеющим смысл.
Прежде всего, подобные комментарии в конце блока:
while ( a ? b ){
for ( i = 10; --1 >= 0; ){
f( i );} // for} // whileне дают ничего, кроме неразберихи, если блоки короткие. Я использую их только тогда, когда составной оператор слишком велик, чтобы поместиться на экран (в моем текстовом редакторе около 40 строк) или в нем столько уровней вложений, что я не могу понять суть происходящего. Комментарии в конце блока обычно целесообразны в больших составных операторах, но мне приходилось часто видеть подобный код:На первой странице:
while ( a ? b ){
while ( something_else() )
{
for ( i = 10; --1 >= 0; ){
for ( j = 10; --j >= 0; ){
// далее идет масса кодаНа какой-то из последующих страниц: } // for} // for} // while} // while
Эти комментарии слишком кратки, чтобы быть полезными. Завершающие блок комментарии должны полностью описывать управляющий оператор. Завершающие блок комментарии из предыдущего примера должны выглядеть таким образом: } // for ( j = 10; --j >= 0; )} // for ( i = 10; --1 >= 0; )} // while ( something_else() )} // while ( a ? b )
Так как #ifdef почти всегда расположен на некотором расстоянии от #endif, то я всегда ставлю метку у #endif:#ifndef __SOMEFILE_H_
#define __SOMEFILE_H_
// здесь следует 1000 строк программы
#endif // __SOMEFILE_H_
То же самое я делаю с #else.
33. Располагайте в строке только один оператор.
Нет абсолютно никакой причины упаковывать в одну строку столько операторов, сколько сможете, если у вас нет намерения сделать программу нечитаемой. Если в строке больше одной точки с запятой, то что-то неверно. Не используйте запятую-оператор (даже если вы знаете, что это такое) по той же причине. Очевидным исключением является оператор for, все три части которого должны быть на одной строке.
34. Указывайте имена аргументов в прототипах функций.
Это особенно важно в определениях классов. Страницы руководств (и встроенных систем помощи) для программы, над которой вы старательно работаете, вряд ли существуют в тот момент, когда они вам нужны больше всего - когда вы начинаете разработку. Вы обычно получаете документацию из двух мест: комментариев, добавленных к настоящим функциям и заголовочных файлов. Из них обычно лучше заголовочный файл, как более компактный. В любом случае из документации, которая на самом деле нужна по функции, вам необходимо знать порядок и число аргументов, а легче всего найти эту информацию в прототипе функции. Если ваш прототип похож на этот:
some_function( int, int, int, int, int );то вам не удастся получить много помощи.
35. Используйте "предикатную" форму при разбиении длинных выражений.
"Предикатом" в английском языке называется вторая половина предложения - глагол и дополнение, над которым глагол выполняет действие. Порядок слов в английском предложении, конечно, фиксированный: глагол всегда идет первым.
Многие компьютерные языки имитируют структуру английского языка (языки С и С++ попадают в эту категорию). Паскаль, например, даже повторяет пунктуацию английского предложения: с точкой с запятой, отделяющей независимые операторы, и точкой на конце. Вызов функции является хорошим примером предикатной формы: глагол является именем функции, а прямые дополнения (вещи, на которые действует глагол) являются аргументами.
Вы также можете посмотреть на операторы типа глагола, потому что они выполняют некоторое действие над операндами ("объектами"). Это разумно, поэтому используйте ту же самую схему, что и в английском предложении, если вам нужно разбить длинное выражение на несколько строк. Помещайте сначала глагол (оператор):
if ( its_thursday_and_the_moon_is_in_scorpio()|| its_friday_afternoon_and_close_to_quitting_time()
|| i_just_cant_bear_to_look_at_this_computer_for_another_minute()
)
{
go_home();
}
Конечно, вы можете добиться большего, просто сократив имена подпрограмм до чего-то более приемлемого, так чтобы все они поместились на одной строке.Заметьте, как я расположил круглые и фигурные скобки в предыдущем примере с целью придания его структуре большей ясности. И при этом я использовал фигурные скобки, хотя язык этого не требовал, для облегчения поиска оператора, связанного с if. Следующий текст программы читается с большим трудом, потому что хуже видно, где заканчивается if и начинается оператор:
if ( its_thursday_and_the_moon_is_in_scorpio()|| its_friday_afternoon_and_close_to_quitting_time()
|| i_just_cant_bear_to_look_at_this_computer_for_another_minute() )
go_home();
36. Подпрограмма должна помещаться на экране.
Затраты на вызов подпрограмм в С/С++ невелики; если для функции указано ключевое слово inline, то затрат фактически нет. Поэтому хорошая мысль состоит в том, чтобы создавать подпрограммы удобного в обращении размера и использовать их в больших количествах. Имя подпрограммы позволяет добиваться значительной абстракции. Если имена выбраны правильно, то у вас зачастую можете исчезнуть нужда в комментариях.
Вообще, мне нравится, когда рабочая часть подпрограммы (ее текст, в меньшей степени комментарии заголовка и так далее) видна полностью при редактировании; она должна целиком помещаться на экране или в окне.
37. Нужно обеспечивать возможность распечатки всего текста программы.
Часто проще найти ошибку на распечатанной странице, чем на экране, даже на большом. Текст на бумаге легче читается вследствие более высокого разрешения и лучшего фокусного расстояния, чем на экране. При этом вы можете разложить бумажные распечатки по всей поверхности стола. Вы вряд ли чем-нибудь сможете заменить бумагу в этом плане, если только у вас нет монитора с диагональю полтора метра и разрешением 300 точек на дюйм.
Итак, ваша программа должна легко печататься. Подпрограммы должны помещаться по возможности на одной странице (не более 60 строк), и ни одна строка программы не должна быть такой длины, чтобы не поместиться в строку распечатки (около 79 символов, в зависимости от шрифта), даже если ваш текстовый редактор поддерживает скролинг по горизонтали. Если вы выйдете за эти пределы, то будете вынуждены использовать столь мелкий шрифт для вывода, что совсем не сможете прочитать свою распечатку.
38. Используйте штриховую линию для зрительного разделения подпрограмм.
Я всегда ставлю такой комментарий:
//---------------------------------------------------------
над каждым определением функции. (И к тому же, я не использую штриховую линию нигде более). Хотя пустые строки замечательно подходят для зрительного разделения блоков программы, исключительно их использование не дает эффекта. Штриховая линия между функциями облегчает их поиск. Так же как пустая строка указывает на границу абзаца, штриховые линии подобны заголовкам разделов. Если мне нужно еще более четкое разделение, то я использую:
//==========================================================//ОПИСЫВАЮЩИЙТЕКСТ //==========================================================
Подумайте об этом, как о заголовке для главы. Я стараюсь не помещать никаких комментариев, за исключениемштриховых линий, вне функции, потому что такие комментарии затрудняют обнаружение определений этой функции. При этом я форматирую функции следующим образом:
//---------------------------------------------------------void descriptive_name( type descriptive_name )
{
// Если имена функции и аргументов недостаточно содержа-// тельны, то я помещаю здесь комментарий, описывающий,
// что она делает. Я опускаю этот комментарий, если имена
// достаточно понятны. (Соответствующее правило гласит:
// "Не объясняй очевидного").
//
// Затем я описываю возвращаемое значение и аргумент.
// И вновь вы можете не использовать комментарий, если
// имена достаточно удачные.
//
// Наконец, я помещаю здесь комментарий, описывающий, как
// функция делает то, что она делает. И снова я пропускаю
// этот комментарий, если программа сама по себе доста
// точно содержательна.
code_goes_here();
}
39. Пробел - один из наиболее эффективных комментариев.
Это кажется мелочью, но это может чрезвычайно улучшить читаемость вашей программы. Обратите внимание, как используются пробелы в этой книге в качестве организующего средства, и вы поймете, как использовать их в своей собственной программе. Пустые строки (или отступ в первой строке) зрительно разделяют абзацы. Пробел следует за точкой, но не должен ей предшествовать, потому что точка завершает что-либо. Вы получили идею. А вот правила:
- Разбивайте текст программы на логические куски (т.е. абзацы), где каждый кусок выполняет одну операцию. Окружите эти куски или пустыми строками, или строками с фигурными скобками.
- За знаком препинания всегда должен идти пробел.
- Операторы являются сокращениями слов. Когда вы видите "+", то говорите "плюс". Подобно любому сокращению, вы должны окружать идентификатор пробелами. (Например: a + b читается "a плюс b", a+b читается "aплюсb").
- Исключение составляют унарные операторы, которые рассматриваются как словарные префиксы или суффиксы (*p,a--,f(arg,arg), и т.д.).
- . или -> в С/С++ являются эквивалентом символа подчеркивания. До и после них пробелов быть не должно: p->msg(), obj.msg().
y=(x/*p++);
f(int /* place-holder */);
Если вы удалите комментарии, то получите: int *p;y=(x
);Сочетание /* в выражении y=(x/*p++) расценивается как символ начала комментария, который заканчивается сочетанием */ в вызове функции f(). (Такой случай действительно со мной произошел, и мне потребовался целый день, чтобы в нем разобраться. Естественно, компилятор не давал сообщений об ошибках, потому что здесь все синтаксически правильно).Еще замечание по данному поводу. Мне часто приходилось позднее видеть объявления подобные следующему:
int* x;Проблема состоит в том, что: int* x, y;не объявляет два указателя, как подсказывает распределение пробелов. Здесь мы имеем на самом деле еще одну проблему из рода "я могу на любом языке программирования писать как на ФОРТРАНЕ". Было бы прекрасно, если бы С работал также, как подсказывает предыдущее форматирование, но это не так. После правильного форматирования int *x, y;становится совершенно ясно, что x - указатель, а y - нет.
40. Используйте отступы в четыре пробела.
Никлас Вирт, который изобрел языки Паскаль и Модула-2, однажды выпустил книгу, где всюду использовались отступы в один символ. Чтение листингов из нее представляло одно из самых тяжелых случаев в моей практике. Используйте достаточно большие отступы, чтобы ваш читатель мог сказать, что в тексте видно абзацы; четыре пробела кажутся идеальными.
Вы должны делать отступы последовательно. Даже во внешнем блоке подпрограммы должны быть отступы. Такой вариант не приемлем:
void f(void){
if ( x )
yyy();more_cod();even_more_code();
}
потому что слишком трудно найти начало подпрограммы. Сравните предыдущий вариант со следующим: void f(void){
if ( x )
yyy();more_cod();even_more_code();
}
41. Условные операторы выделяются абзацными отступами.
Я делаю это даже в операторах из одной строки:
if ( by_land )one();
else
two();
а не так: if ( by_land ) one() else two();Очевидным исключением является: if ( by_land ){
one();
}
else if ( by_sea )
{
two();
}
else if ( by_air )
{
three();
}
Я использовал здесь скобки по двум причинам. Во-первых, я как-то попал внутрь условного оператора при отладке и забыл вставить скобки, как в следующем тексте: if ( by_land )one(); if(debug) printf("aagh");
else if ( by_sea )
что привело привело фактически к: if ( by_land )one();
if (debug)
printf("aagh");
else
if ( by_sea )
Со скобками программа к тому же лучше читается. Я часто нарушаю правило абзацных отступов, когда используюформатирование для того, чтобы показать с кристальной ясностью, что происходит. Аккуратные столбцы делают это осуществимым:
if ( by_land ) one();else if ( by_sea ) two();
else if ( by_tunnel ) three();
но это нечитаемо: if (by_land)one();else if(by_sea)two();
else if(by_tunnel)three();
Подобный код никуда не годится: for ( a ; b ; c );while ( ++i ? 10 );
Слишком просто случайно сделать следующее: while ( i ? 10 );++i;
(Другими словами, "вечно сравнивать i с 10, затем увеличить i"). Если точка с запятой никогда не ставится в конце строки, начинающейся с for или while, то вы можете использовать утилиту поиска строки типа grep для обнаружения таких проблем.
41.1. Комментарии должны иметь тот же отступ, что и окружающий текст программы.
Абзацные отступы предназначены для того, чтобы сделать структуру вашей программы легко понятной. Если вы организуете отступы в комментариях беспорядочным образом, то этим вы лишите их смысла. Комментарий в следующей программе должен быть снабжен отступами:
f(){ /* Здесь идет
** длинный комментарий
*/
code();
}
Здесь имеется сходная проблема: f(){
int local_var;
int another_local_var;
code();
}
Отсутствие отступа при определении локальных переменных заставляет предположить, что они находятся в той же области видимости, что имя функции (которая является глобальной). Так как это не так, то вы должны сделать отступ, чтобы указать на область видимости: f(){
int local_var;
int another_local_var;
code();
}
42. Выравнивайте скобки вертикально по левой границе.
Иногда поиск отсутствующей фигурной скобки превращается в крупную проблему. Если вы вынесете скобки туда, где их хорошо видно, то их отсутствие будет сразу же заметно:
while ( some_condition ){
// внутренний блок
}
Я в самом деле не люблю так называемый стиль Кэрнигана и Ричи: if ( condition {code();
}else{
more_code();
}
Здесь не только трудно проверить скобки на парность, но и отсутствие зрительного разделения за счет строк, содержащих лишь открытые скобки, ведет к ухудшению читаемости.
43. Используйте скобки, если в условном операторе имеется более, чем одна строка.
Это правило применяется, если даже дополнительными строками является комментарий. Проблема заключается в том, что слишком легко случайно добавить другой оператор и забыть добавить скобки. Текст, подобный нижеследующему, более надежен:
if ( something() ){
/* Quo usque tandem abutere
* Gatesalina, patientia
* nostra* .
*/
somethig_else();
}
Глава 4. Имена и идентификаторы
Имена играют важную роль. Правильно выбранные имена могут сделать программу поистине самодокументированной, не требуя совсем или требуя мало дополнительного набора в виде явных комментариев. Плохо выбранные имена (например, state - состояние или штат ?) могут добавить ненужную сложность в вашу программу. Эта часть книги содержит правила выбора имен.
44. Имена должны быть обычными словами английского языка, описывающими то, что делает функция, аргумент или переменная.
Избегайте аббревиатур; они ухудшают читабельность программ. Некоторые по привычке продолжают использовать аббревиатуры, что приводит к абсурдной практике, типа отбрасывания последней буквы слова или удаления из него всех гласных. Возьмем странно названную функцию UNIX creat(); очевидно, что create() лучше. Я также видел странности типа lnghth вместо length и mt вместо empty.
При этом общепринятые аббревиатуры являются очевидными исключениями. Вот тот минимум из них, которым я пользуюсь сам:
| col | индекс столбца |
| cur | текущий |
| i j | обобщенные счетчики циклов |
| max | максимум (обычно в качестве префикса или суффикса) |
| min | минимум (обычно в качестве префикса или суффикса) |
| obj | обобщенный объект (имеется указатель на базовый класс, но производный класс не известен) |
| p ptr | обобщенный указатель |
| s str | строка (в языке С обычно char*) |
putchar('-');
Используйте настоящее имя, если вы применяете счетчик для чего-нибудь отличного от счета. Сравните этот код: for ( i = 0; i ? imax; ++i )for ( j = 0; j ? jmax; ++j )
move_cursor( i,j );со следующим: for ( row = 0; row ? max_row; ++row )for ( col = 0; col ? max_col; ++col )
move_cursor( row, col );Я также избегаю использовать x и y вместо row и column. Одно из ранее указанных правил рекомендует пропускать программу через систему проверки орфографии. Действительное достоинство этого метода состоит в том, что он побуждает вас использовать в качестве имен обычные слова.44.1. Не используйте в качестве имен тарабарщину.
Отличный образец такого подхода можно наблюдать в любом предлагаемом Microsoft примере программы, хотя эта проблема ни в коем случае не ограничивается корпорацией Microsoft. Все демонстрационные программы Microsoft Windows включают тип переменной в ее имя. Например, объявление типа:
const char *str;будет сделано следующим образом: LPCSTR lpszstr;Переведите lpszstr как "указатель типа long с именем str на строку, оканчивающуюся 0". На самом деле здесь несколько проблем, не последней из которых является тот факт, что LPCSTR скрывает наше объявление указателя. Тем не менее обсуждаемое правило посвящается проблеме самого имени.Этот стиль выбора имен называется "венгерской" записью по названию родины руководителя отдела программирования Microsoft Чарльза Саймони, который его изобрел. (А не потому, что его использование придает программам Microsoft такой вид, как будто они написаны на венгерском языке.)
Венгерская запись целесообразна для языка ассемблера, в котором все, что вы знаете о переменной - это ее размер. Включение информации о типе в имя переменной позволяет вам контролировать правильность ее использования. Языки более высокого уровня типа С и С++ используют для этой цели объявление переменных.
Доктор Саймони несколько раз в печати защищал такой метод записи, но я бы не стал его рекомендовать для программ на С или С++. По моему мнению, венгерская запись не дает ничего, кроме ухудшения читаемости программ. Простые str или string значительно легче читаются и содержат ту же информацию. Если вам на самом деле нужно узнать тип, то для этого достаточно вернуться к определению.
Существует и более распространенный, хотя и менее радикальный прием, при котором имена указателей начинают символом p. Эта практика тоже загромождает программу. Вы ведь не начинаете имена целочисленных переменных типа int символом i, переменных типа double - d, а функций - f? Очевидным исключением является случай, когда у вас есть объект и указатель на этот объект в одной и той же области видимости:
char str[128], *pstr = str;c другой стороны, для указателя, вероятно, лучше содержательное имя. Сравните: char str[128], *first_nonwhite = str;while ( isspace(*first_nonwhite) )
++first_nonwhite;
// В этой ситуации имя *first_nonwhite говорит вам гораздо
// больше о том, что делает переменная, чем предыдущее "*pstr".
45. Имена макросов должны записываться ЗАГЛАВНЫМИ_БУКВАМИ.
Как показывается в последующих разделах, макросы часто вызывают побочные эффекты. Поэтому полезно иметь возможность определить с первого взгляда, что у вас является макросом. Конечно, вы не должны использовать только заглавные буквы для чего-нибудь помимо макросов, иначе вы не достигнете цели данного правила.
45.1. Не используйте заглавных букв для констант перечисления.
Должна быть обеспечена возможность замены констант, определенных в перечислении, на переменную типа const. Если ее имя записано заглавными буквами, то вам придется его менять. Кроме того, имеются еще и проблемы с макросами (вскоре будут рассмотрены), которых нет у перечислений. Поэтому будет полезно иметь возможность различать их с первого взгляда.
45.2. Не используйте заглавных букв в именах типов, созданных при помощи typedef.
Так как макрос также может использоваться в манере, подобной typedef, то полезно знать может или нет что-то быть использовано в качестве синтаксически правильного типа. Например, имея:
typedef void (*ptr_to_funct)(int );вы можете написать следующее: (ptr_to_funct)( p ); // преобразует p в указатель на функциюptr_to_funct f(long); // f возвращает указатель на функцию
Макрос типа: #define PTR_TO_FUNCTION void (*) (int )позволяет вам сделать преобразование: (PTR_TO_FUNCTION) ( p );но не позволяет объявить функцию: PTR_TO_FUNCTION f(long);Указанный макрос при подстановке дает: void (*) (int ) f(long);но компилятору нужно: void (*f(long))(int );Имя типа из строчных букв не вызовет никаких проблем при чтении, потому что по смыслу вы всегда можете сказать, используется ли оно для типа или нет.
46. Избегайте области имен стандарта ANSI C.
Идентификаторы, начинающиеся с символа подчеркивания, и имена типов, оканчивающиеся на _t, были зарезервированы стандартом ANSI C для использования разработчиками компиляторов. Не используйте эти символы. Также избегайте имен функций, вошедших в стандарт ANSI C и в проект стандарта ISO/ANSI для С++.
47. Избегайте области имен Microsoft.
Это может показаться правилом, специфичным только для Microsoft, но на самом деле это не так (учитывая имеющуюся склонность Microsoft к мировому господству). Любой, кто заботится о переносимости, должен рассчитывать на то, что его или ее программа со временем может или работать под управлением операционной системы Microsoft, или взаимодействовать с библиотекой классов Microsoft. Библиотека MFC, например, перенесена на Macintosh и во многие операционные среды UNIX/Motif на момент написания этой книги, и, вероятно, появится на других операционных системах в ближайшем будущем.
На момент написания этой книги интерфейс прикладного программирования Windows (API) включает в себя около 1200 функций. Библиотека MFC, быстро вытесняющая первоначальный интерфейс на языке С, добавляет около 80 определений классов. К сожалению, метод Microsoft состоит в добавлении каждый раз дополнительных функций и классов в новую версию компилятора. Если Microsoft случайно выберет в качестве имени для функции или класса то, которое вы используете для каких-то других целей, угадайте, кому из вас придется его сменить?
Так как ни один из идентификаторов Microsoft не соответствует стандарту ANSI C, требующему, чтобы имена поставляемых разработчиком объектов начинались с символа подчеркивания, то вы должны предохраняться, избегая использования соглашений по выбору имен в стиле Microsoft:
Все имена функций Microsoft используют соглашения в стиле Паскаля о СмесиЗаглавныхИСтрочныхБукв(), и они всегда начинаются с заглавной буквы. Я предпочитаю имена только из строчных букв с символами подчеркивания, но что бы вы не выбрали, НеИспользуйтеСтильMicrosoft(). Функции-члены в классах MFC используют то же самое соглашение.Одна из наиболее фундаментальных заповедей объектно-ориентированного проектирования запрещает оставлять незащищенными данные-члены в определении класса. Тем не менее, многие классы MFC имеют открытые поля данных. Все эти поля начинаются с m_, не имеющих другого назначения, кроме как увеличить беспорядок. Тем не менее, мы можем использовать эту бессмыслицу для того, чтобы не начинать имена своих собственных полей с m_ и таким образом легко отличать свои члены от унаследованных из базовых классов MFC.
48. Избегайте ненужных идентификаторов.
Имена для констант часто вообще не нужны. Например, не определяйте значения, возвращаемые при ошибке; если возвращается всего одна ошибка, возвратите просто FALSE. Не делайте так:
enum { INSERT_ERROR, DELETE_ERROR };insert()
{
//...
return INSERT_ERROR;
}
delete()
{
//...
return DELETE_ERROR;
}
а просто возвратите 0 в случае ошибки и в случае успеха любое правильное значение типа 1.
49. Именованные константы для булевых величин редко необходимы.
Выбор неверного имени может добавить значительную ненужную сложность в вашу программу. Рассмотрим следующую простейшую функцию, которая подсчитывает количество слов в строке:
int nwords(const char *str){
typedef enum { IN_WORD, BETWEEN_WORDS } wstate;
int word_count = 0;
wstate state = BETWEEN_WORDS;
for (; *str ; ++str )
{
if ( isspace(*str) ) state = BETWEEN_WORDS;else if ( state != IN_WORD ){
++word_count;state = IN_WORD;
}}return word_count;
}
Неправильно выбранное имя state заставило нас ввести два ненужных идентификатора: IN_WORD и BETWEEN_WORDS. Теперь взгляните на этот вариант: int nwords2(const char *str){
int word_count = 0;
int in_word = 0;
for (; *str ; ++str )
{
if ( isspace(*str) ) in_word = 0;else if ( !in_word ){
++word_count;in_word = 1;
}}return word_count;
}
Переименование нечетко названной переменной state во что-нибудь, что действительно описывает назначение переменной, позволило мне исключить булевые именованные константы IN_WORDS и BETWEEN_WORDS. Получившаяся подпрограмма меньше и легче читается.Вот другой пример. Следующая программа:
enum child_type { I_AM_A_LEFT_CHILD, I_AM_A_RIGHT_CHILD };struct tnode
{
child_type position;
struct tnode *left,
*right;} t;//...
t.position = I_AM_LEFT_CHILD;
if ( t.position == I_AM_LEFT_CHILD )
//...может быть упрощена подобным образом: struct tnode{
unsigned is_left_child ;
struct tnode *left,
*right;} t;t.is_left_child = 1;
if ( t.is_left_child )
//...
тем самым исключая два ненужных идентификатора. И вот последний пример: enum { SOME_BEHAVIOR, SOME_OTHER_BEHAVIOR, SOME_THIRD_BEHAVIOR };f( SOME_BEHAVIOR , x);
f( SOME_OTHER_BEHAVIOR, x);
f( SOME_THIRD_BEHAVIOR, x);
требующий четырех идентификаторов (три именованные константы и имя функции). Лучше, хотя это не всегда возможно, исключить селекторную константу в пользу дополнительных функций: some_behavior(x);some_other_behavior(x);
some_third_behavior(x);
Обратной стороной этой монеты является вызов функции. Рассмотрим следующий прототип: create_window( int has_border, int is_scrollable, int is_maximized );Я снова выбрал рациональные имена для исключения необходимости в именованных константах. К сожалению, вызов этой функции плохо читаем: create_window( TRUE, FALSE, TRUE );Просто взглянув на такой вызов, я не получу никакого представления о том, как будет выглядеть это окно. Несколько именованных констант проясняют обстоятельства в этом вызове: enum { UNBORDERED =0; BORDERED =1}; // Нужно показать значенияenum { UNSCROLLABLE=0; SCROLLABLE =1}; // или create_window()
enum { NORMAL_SIZE =0; MAXIMIZED =1}; // не будет работать.
//...
create_window( BORDERED, UNSCROLLABLE, MAXIMIZED );
но теперь у меня другая проблема. Я не хочу использовать именованные константы внутри самой create_window(). Они здесь только для того, чтобы сделать ее вызов более читаемым, и я не хочу загромождать эту функцию таким кодом, как: if ( has_border == BORDERED )//...
сравнивая его с более простым: if ( has_border )//...
Первый вариант уродлив и многословен. К сожалению, если кто-то изменит значение именованной константы BORDERED, второй оператор if не будет работать. Я обычно соглашаюсь с мнением, что программист, занимающийся сопровождением, не должен менять значения идентификаторов, как я это проделал в предыдущем примере.
Глава 5. Правила обычного программирования
Эта часть содержит правила, относящиеся к написанию собственно исходного текста программы, в отличие от предыдущей части, в которой рассматривалась разработка программы в целом. Эти правила не слишком зависят от выбора языка программирования.
50. Не путайте привычность с читаемостью.
(Или синдром "настоящего программиста, который может программировать на любом языке как на ФОРТРАНе"). Многие люди пытаются злоупотреблять препроцессором для того, чтобы придать С большее сходство с каким-нибудь другим языком программирования. Например:
#define begin {#define end }
while ( ... )
begin
// ...
end
Эта практика ничего не дает, кроме того, что ваш код становится нечитаемым для кого-нибудь, кто не знает того языка, который вы стараетесь имитировать. Для программиста на С код станет менее читаемым, не более того.Родственная проблема связана с использованием макросов препроцессора для скрытия синтаксиса объявлений С. Например, не делайте следующего:
typedef const char *LPCSTR;LPCSTR str;
Подобные вещи вызывают проблемы с сопровождением, потому что кто-то, не знакомый с вашими соглашениями, будет должен просматривать typedef, чтобы разобраться, что происходит на самом деле. Дополнительная путаница возникает в С++, потому что читатель может интерпретировать происходящее, как определение объекта С++ из класса LPCSTR. Большинству программистов на С++ не придет в голову, что LPCSTR является указателем. Объявления С очень легко читаются программистами на С. (Кстати, не путайте вышеупомянутое с разумной практикой определения типа word в виде 16-битового числа со знаком для преодоления проблемы переносимости, присущей типу int, размер которого не определен в ANSI С и С++).К тому же, многие программисты избегают условной операции (?:) просто потому, что она им кажется непонятной. Тем не менее, это условное выражение может существенно упростить ваш код и, следственно, сделать его лучше читаемым. Я думаю, что:
printf("%s", str ? str : "?пусто>");гораздо элегантнее, чем: if ( str == NULL )printf( "?пусто>" );
else
printf( "%s", str );
Вы к тому же экономите на двух вызовах printf(). Мне также часто приходится видеть неправильное использование операций ++ и --. Весь смысл автоинкремента или автодекремента заключается в соединении этих операций с другими. Вместо: while ( *p ){
putchar ( *p );
++p;
}
или: for ( ; *p ; ++p )putchar ( *p );
используйте: while ( *p )putchar ( *p++ );
Этот код вполне читаем для компетентного программиста на языке С, даже если ему нет эквивалентной операции в ФОРТРАНе или Паскале.Вы также никогда не должны прятать операторы в макросах из-за того, что вам просто не нравится, как они выглядят. Я однажды видел следующее в реальной программе:
struct tree_node{
struct tree_node *lftchld;
};
#define left_child(x) ((x)->lftchld)
//...
traverse( tree_node *root )
{
if ( left_child(root) )
traverse( left_child( root ) );// ...}
Программист намеренно сделал определение структуры труднее читаемым для того, чтобы избежать конфликта имен между полем и совершенно необходимым макросом, и все из-за того, что ему не нравился внешний вид оператора ->. Для него было бы гораздо лучшим выходом просто назвать поле left_child и совсем избавиться от макроса.Если вы действительно думаете, что программа должна внешне выглядеть как на Паскале, чтобы быть читаемой, то вы должны программировать на Паскале, а не на С или С++.
51. Функция должна делать только одно дело.
Это обычно не очень удачная мысль - записывать то, что должна делать функция, через ее аргументы. Это должно делать имя функции. Например:
UpdateAllViews( CView *sender, long lhint, CObject *phint ){
| // sender | lhint | phint | |
| // NULL | xx | xx | Начальное обновление, вызываемое из обрамляющего окна |
| // Cview* // // | 0 | CRect* | Вызывается, когда встроенный объект становится действительным. phint указывает на прямоугольник документа, сохраняя положение недействительного объекта |
| // Cview* // // | 1 | CRect* | Сообщение, посылаемое объектом CView* ("sender" - передатчик). phint сохраняет для CView* обрамляющее окно его клиента. |
| // ... |
Вам нужны вместо этого три функции: initial_update(), update_embedded_object() и update_view(). Верным ключом для понимания того, что здесь что-то не так, является туманная природа имен аргументов. Функции не должны передаваться "намеки". Ей должны даваться указания.
52. Иметь слишком много уровней абстракции или инкапсуляции так же плохо, как и слишком мало.
Основной смысл использования таких абстракций, как функции или символьные константы (или инкапсуляций, подобных определениям struct или class), заключается в улучшении читаемости программ. Не пользуйтесь ими просто потому, что вы можете делать это. Например, вложенные структуры в данном фрагменте не служат какой-либо полезной цели:
struct tree_node;struct child_ptr
{
unsigned is_thread;
struct tree_node *child;
};
struct tree_node
{
struct child_ptr left,
right;};tree_node *p;
if ( !p->left.am_a_thread )
p = p->left.child;
Следующий код лучше читается, потому что в нем меньше точек, и легче сопровождается, так как в нем нужно отлаживать на одно определение меньше: struct tree_node{
struct tree_node *left_child;
unsigned left_is_thread : 1;
struct tree_node *right_child;
unsigned right_is_thread : 1;
};
if ( !p->left_is_thread )
p = p->left_child;
53. Функция должна вызываться более одного раза, но...
Кроме того, если функция должным образом связана (т.е. если она выполняет единственную операцию и весь код функции работает на ее результат), то нет причины извлекать кусок кода в другие функции, если только вы не желаете использовать эту часть кода где-то еще. Мой опыт говорит, что когда функция становится слишком большой, то часто возможно выделить куски, которые обладают достаточной общностью, чтобы быть использованными где-либо еще в программе, так что это правило на самом деле не противоречит правилу "маленькое - прекрасно". Если вы не выделяете этот код, то блочный комментарий, описывающий назначение этого блока программы, который вы могли бы выделить, служит той же самой цели, что и имя функции - документированию.
Тем не менее, иногда выделение кода в функции меньшего размера существенно улучшает читаемость этого кода по причине устранения беспорядка. Однако эта практика - создание абстракции для части кода в виде имени функции - добавляет идентификаторы в область глобальных имен, и эта возросшая общая сложность является определенным минусом. Если я использую функцию этим способом - как абстракцию -, то обычно обяъвляю ее одновременно статической, чтобы к ней нельзя было получить доступ снаружи текущего файла, и встроенной, чтобы ее вызов не приводил к накладным расходам. Не доводите процесс функционального абстрагирования до крайности. Мне доводилось видеть отличные программы, доведенные абстрагированием до полностью нечитаемого состояния такой степени, что нет ни одной функции длиннее, чем 5 или 6 строк. Получающаяся программа работает также значительно медленнее, чем необходимо, и ее исходный текст в 5 раз длиннее, чем нужно.
53.1. Код, используемый более одного раза, должен быть помещен в функцию.
Это правило является обратной стороной предыдущего. Если вы обнаруживаете почти идентичный код появляющимся более чем в одном месте своей программы, то этот код должен выделен в подпрограмму, которая вызывается из нескольких мест. Выгода состоит в меньшем размере программы и лучшей сопровождаемости вследствие упрощения программы и того, что вы должны теперь сопровождать лишь одну функцию; если вы находите ошибку, то вам нужно исправить ее только в одном месте. Как было упомянуто ранее, имя функции также дает хорошую абстракцию. Вызовы функции с хорошо выбранным именем являются обычно самодокументирующимися, устраняя необходимость в комментариях.
54. Функция должна иметь лишь одну точку входа.
Это правило применимо лишь к программам на С. Вообще, множество переходов goto к одной точке выхода лучше, чем много операторов return. Этим способом вы можете поместить точку прерывания у единственной точки выхода, вместо того чтобы возиться с несколькими прерываниями. Например:
f(){
int возвращаемое_значение = ОШИБКА;
if ( некое_условие )
{
// ...
возвращаемое_значение = НЕЧТО;
goto выход;
}
else
{ // ...
возвращаемое_значение = НЕЧТО_ЕЩЕ;
goto выход;
}
exit:
return возвращаемое_значение;
}
Этот метод не срабатывает в С++, потому что функции конструктора вызываются неявно в качестве части объявления; объявление часто скрывает вызов функции. Если вы пропускаете объявление, то вы пропускаете и вызов конструктора. Например, в следующей программе деструктор для x вызовется, а конструктор нет: foo(){
if ( некое_условие )
goto выход;
некий_класс x; // Конструктор не вызывается. (Оператор goto
// перескакивает через него.)// ...выход:
// Здесь вызывается деструктор для x при выходе x из} // области видимости.Вследствие этой проблемы лучше всего совсем избегать переходов goto в программах на С++.54.1. Всегда предусматривайте возврат значения из блока внешнего уровня.
Иногда, когда подпрограммы короткие, не стоит стараться обеспечить единственную точку выхода. (По моему мнению, правило "избегай запутанности" перекрывает любое другое правило, с которыми оно входит в конфликт). В этой ситуации всегда старайтесь убедиться, что из подпрограммы нет таких путей, которые не проходят через оператор return. Не так:
if ( a ){
// ...
return делай_что_нужно();
}
else
{
// ...
return ОШИБКА;
}
а так: if ( a ){
// ...
return делай_что_нужно();
}
// ...
return ОШИБКА;
В идеале, выход по ошибке организуется из внешнего уровня блока так, чтобы вы правильно обработали неожиданный аварийный выход на внешний уровень.
55. Избегайте дублирования усилий.
Следующий фрагмент демонстрирует эту проблему:
if ( strcmp(a, b) ? 0 ){
}
else if ( strcmp(a, b) > 0 )
{
}
else if ( strcmp(a, b) == 0 )
{
}
Вызов strcmp() в С связан с немалыми накладными расходами (как в Паскале и других языках программирования). Вам значительно лучше сделать так: int cmp = strcmp(a, b);if ( cmp ? 0 )
{
}
else if ( cmp > 0 )
{
}
else // остается случай cmp == 0
{
}
56. Не портьте область глобальных имен.
Порча области глобальных имен является характерной проблемой в среде групповой разработки. Вам не очень понравится спрашивать разрешение от каждого участника группы каждый раз, когда вы вводите новый идентификатор. Поэтому:
- Локальная переменная всегда более предпочтительна, чем член класса.
- Член класса всегда более предпочтителен, чем статическая глобальная переменная.
- Статическая глобальная переменная всегда более предпочтительна, чем настоящая глобальная переменная.
Вывод: избегайте препроцессора. Так как у макроса такая большая область видимости, то он по сути то же самое, что и глобальная переменная.
56.1. Избегайте глобальных идентификаторов.
Раскрывая немного предыдущее правило, положим, что две функции связаны посредством глобальной переменной, если одна из них устанавливает эту переменную, а вторая ее использует. (Если бы глобальная переменная не использовалась совместно, то не было бы причины иметь ее глобальной; она могла бы быть статической локальной). Отношения связи с участием глобальных переменных вызывают особенно неприятные проблемы при сопровождении, потому что эти отношения тяжело отслеживать. Когда глобальная переменная меняется во время выполнения программы, то очень трудно разобраться, что ее изменило. Аналогично, если вы должны изменить поведение глобального объекта, то очень трудно разобраться, где он используется. По этой причине лучше всего вообще избегать глобальных переменных. Конечно, большинству программ реального мира необходимо незначительное количество глобальных переменных, но, как правило, я начинаю сильно нервничать, если их становится больше 10.
Вы зачастую можете ограничить область видимости глобальной переменной одним файлом, объявив ее статической, что по меньшей мере ограничит ущерб одним файлом. По крайней мере вы знаете, что все отношения связи сосредоточены в текущем файле. Также имейте ввиду, что все, что я говорил о глобальных переменных, относится и к макросам, функциям и так далее. Ограничивайте доступ к функциям, делая их любой ценой статическими.
56.2. Никогда не требуйте инициализации глобальной переменной при вызове функции.
Вот одна ситуация, где оправданы статические глобальные переменные: если у вас применяется система рекурсивных функций. (Вы можете использовать статические глобальные переменные для сокращения потребного объема стековой памяти, применяя их для передачи значений между подпрограммами. Вам никогда не нужно использовать статическую глобальную переменную для передачи информации из одной подпрограммы в другую, являющуюся рекурсивным экземпляром той же самой подпрограммы. Верным выбором в этой ситуации будет использование локальной статической переменной. Используйте статические глобальные переменные в ситуациях, где вызывается более одной подпрограммы: A() вызывает B(), которая вызывает A(), вызывающую в свою очередь B(), и так далее).
Так как глобальная переменная, используемая нашей рекурсивной функцией, сделана статической для минимизации связывания, то как вам ее инициализировать? Далее показано как не нужно этого делать. Вот файл 1:
static int glob;get_glob( x )
{
return glob;
}
set_glob( x )
{
glob = x;
}
void recursive_function( void )
{
int y = glob
// ...
recursive_function();
}
а вот файл 2: set_glob( 10 );recursive_function();
x = get_glob();
Вы при этом немногого достигли с точки зрения связывания; на самом деле, с простой глобальной переменной было бы проще управляться. Кроме того, вы подготовили себе потенциальную проблему: возможность забыть вызвать set_glob(). Вот как сделать это правильно: static int glob;static void recursive_function( void )
{
int y = glob;
// ...
recursive_function();
}
int do_recursive( int init_val )
{
glob = init_val;
recursive_function();
return glob;
}
Ни к глобальной переменной, ни к рекурсивной функции нельзя получить доступ прямо снаружи модуля из-за статического выделения памяти. Вы должны получить доступ к рекурсивной функции посредством функции доступа do_recursive(), которая гарантирует, что все инициализировано правильно перед тем, как выполнить вызов рекурсивной функции.56.2.1. Делайте локальные переменные статическими в рекурсивных функциях, если их значения не участвуют в рекурсивном вызове.
Так как мы занялись темой рекурсии, то вот правило, которое используется для того, чтобы еще сильнее сократить использование стека. Локальная переменная может быть объявлена статической (тем самым она удаляется из стека), если ее значение не должно сохраняться после рекурсивного вызова. Вот один пример:
f(){
static int i;
// ...
for ( i = 10; --i >= 0; )
// ...f();for ( i = 10; --i >= 0; ) // переменная i вновь инициализируется после
// ... // рекурсивного вызова, поэтому она может} // быть статической.Вот другой: int f(){
static int depth = 0;
static int depth_max = 0;
++depth; depth_max = max( depth, depth_max );
if ( depth > 10 )
return -1; // уровень рекурсии слишком глубок.
f();
--depth;
return depth_max;
}
В этом последнем случае переменная depth используется для передачи информации - глубины рекурсии - от одного экземпляра подпрограммы другому, рекурсивному экземпляру этой же самой подпрограммы. Переменная depth_max хранит след достигнутой максимальной глубины рекурсии. depth вовсе не будет работать, если она должна будет сохранять свое значение после вызовов - весь смысл в том, что каждый рекурсивный вызов модифицирует эту переменную.56.3. Используйте счетчик экземпляров объектов вместо инициализирующих функций.
Инициализирующие функции, с очевидным исключением в виде конструкторов С++, не должны использоваться просто потому, что слишком просто забыть их вызвать. Многие системы с оконным интерфейсом, например, требуют, чтобы вы вызывали функцию инициализации окна перед его созданием (и другую - закрытия - после удаления последнего окна). Это плохая идея. Уладьте эту проблему при помощи счетчика экземпляров, который обычно в С должен быть глобальной переменной (объявленной статической для ограничения области ее видимости). Сделайте это так:
static int num_windows = 0; // ограничьте доступ к текущему модулюcreate_window()
{
if ( ++num_windows == 1 ) // только что создано первое окно
initialize_video_system();
// ...
}
destroy_window()
{
// ...
if ( --num_windows == 0 ) // только что уничтожено первое окно
shutdown_video_system();
}
static int число_окон = 0; // ограничьте доступ к текущему модулю
создать_окно()
{
if ( ++число_окон == 1 ) // только что создано первое окно инициализировать_видео_систему();
// ...
}
уничтожить_окно()
{
// ...
if ( --число_окон == 0 ) // только что уничтожено первое окно
закрыть_видео_систему();
}
В С++ вы можете для этой цели использовать статический член класса.56.4. Если оператор if завершается оператором return, то не используйте else.
Вместо:
if ( условие )return xxx;
else
{
делать_массу_вещей();
}
обычно лучше записать: if ( условие )return xxx;
делать_массу_вещей();
Лучше сделать так, чтобы последним оператором return был аварийный возврат по ошибке, так чтобы вы получили сообщение об ошибке, если нечаянно заблудились.Условный оператор также может решать эту проблему в простых ситуациях и делать код более читаемым для новичка. Вместо:
f(){
// ...
if ( x )
return 123;else if ( y ) return 456;else return ERROR;}используйте f(){
// ...
return x ? 123 :
y ? 456 :ERROR ;
}Заметьте, насколько форматирование улучшает читаемость предыдущего кода.Одна распространенная ситуация, в которой у вас имеется множество точек возврата, выглядит следующим образом:
if ( A )return FAIL;
else if ( B )
return SUCCESS;
else
{
// Масса кода
return SUCCESS; // Подозрительны два одинаковых возвращаемых значения.
}
Вы можете устранить это следующим образом. Во-первых, избавьтесь от повтора возвращаемых значений, переместив их во внешний уровень вот так: if ( A )return FAIL;
else if ( B )
;
else
{
// Масса кода
}
return SUCCESS;
Затем освободитесь от предложения if, связанного с пустым оператором: if ( A )return FAIL;
else if ( B )
{
// Масса кода
}
return SUCCESS;
57. Помещайте более короткий блок условного оператора if/else первым.
Часто бывает, что у оператора if/else одно предложение (или внутренний блок) короткое (обычно оператор для обработки ошибки), а другое, выполняющее собственно работу, - большое:
if ( некая_ошибка() )error( "ААААхххх!!!!" );
else
{
// Здесь следуют 30 строк кода
}
Всегда помещайте короткое предложение в начале. То есть, не делайте так: if ( !некая_ошибка() ){
// Здесь следуют 30 строк кода
}
else
error( "ААААхххх!!!!" );
Проблема заключается в том, что проверка в операторе if управляет else в той же степени, что и if. Если большой блок следует первым, то вероятность того, что вычисляться будет предложение else, расположенное на следующем экране или странице, довольно велика. И если я допустил в нем ошибку, то мне придется поломать голову над тем, как добраться до else. Если в это время if в поле зрения, то я знаю, как туда попасть.
58. Старайтесь сдвинуть ошибки с этапа выполнения на этап компиляции.
Неинициализированные переменные - по сути ошибки, ждущие своего часа. Вы всегда должны инициализировать переменную при ее объявлении. В С++ инициализация во время объявления возможна всегда, потому что объявление может проводиться везде, где можно поместить оператор; просто откладывайте объявление до тех пор, пока у вас не будет достаточно информации для объявления в произвольном месте с инициализацией переменной. Таким образом, если вы попытаетесь использовать эту переменную преждевременно, то получите ошибку на этапе компиляции ("переменная не найдена") вместо ошибки во время выполнения.
В С вы можете объявлять переменную после любой открытой фигурной скобки, поэтому вы можете часто откладывать объявление на некоторое время, но при этом у вас в распоряжении нет гибкости С++. В самом крайнем случае инициализируйте переменную таким значением, которое в ответ на него понятным образом вызовет в подпрограмме аварию; не присваивайте переменной произвольное значение - оно может быть принято в программе за имеющее смысл. Например, указатель, инициализированный значением NULL, более надежен, чем имеющий произвольное значение, которое может оказаться существующим адресом.
С другой стороны, хорошо иметь все объявления переменных в одном месте в начале блоке так, чтобы вы могли их легко найти. Если ваша подпрограмма достаточно мала, то вы обычно можете сделать и то, и другое. Например, вы можете разделить подпрограмму на части для того, чтобы переместить объявления в начало блока, чтобы вам их было легче найти. Подпрограмма, подобная следующей:
f(){
// код, который не использует переменную i
int i = init_val;
// код, который использует переменную i
}
может быть разделена следующим образом: f(){
// код, который не использует переменную i
g( init_val );
}
g( int init_val )
{
int i = init_val;
// код, который использует переменную i
}
Переменная-счетчик общего назначения, которая инициализируется в начале цикла for, является очевидным исключением из этого правила. Иногда использование слишком большого количества подпрограмм может вызвать больше проблем, чем решить их, и в этом случае лучше выбрать внутренние объявления. Используйте свою голову.
59. Применяйте указатели на функции С в качестве селекторов.
Это правило строго для программистов на С. (Программирующие на С++ должны использовать виртуальные функции). В С заменяйте подобный код:
typedef enum shape_type { CIRCLE, LINE, TEXT };typedef struct
{
shape_type type;
union shape_data
{ // здесь данные для различных форм.
} data;
} shape;
extern void print_circle( shape *p );
extern void print_line ( shape *p );
extern void print_text ( shape *p );
shape a_circle = { CIRCLE, ... };
print_shape( shape *p )
{
switch( p->type )
{
case CIRCLE: print_circle( p );
case LINE: print_line ( p );
case TEXT: print_text ( p );
}
}
на следующий: typedef struct{
void (*print)( struct *shape );
union shape_data;
{ // здесь данные для различных фигур.
}
}
shape;
extern void print_circle( shape *p );
extern void print_line ( shape *p );
extern void print_text ( shape *p );
shape a_circle = { print_circle, ... };
print_shape( shape *p )
{
( p->type )( p );
}
Главные преимущества такого подхода заключаются в следующем:- Вам больше не нужен перечислитель shape_type.
- Функцию print_shape() теперь написать гораздо проще.
- print_shape() будет продолжать работать без модификации, когда вы добавите новые фигуры в эту систему.
60. Избегайте циклов do/while.
Цикл do/while опасен в принципе, так как вы обязательно выполняете его тело хотя бы один раз. Следовательно, вы должны проверить условия завершения до входа в этот цикл. Я часто вижу код, похожий на следующий:
if ( !проверить_нечто )return ERROR;
do
{
начинка();
} while ( проверить_нечто );
Вам гораздо лучше сделать так: while ( проверить_нечто )начинка();
Похожий случай: if ( некое_условие() )do
// масса материала
while ( некое_условие() ?? другой_материал() );
легче трактовать следующим образом: while ( некое_условие() ){
// масса материала
if ( !другой_материал() )
break;}Я профессионально занимаюсь программированием с 1979 года и за это время использовал цикл do/while всего два раза.60.1. Никогда не используйте do/while для бесконечного цикла.
Код, похожий на следующий:
do{
// здесь следует несколько страниц кода
while ( 1 );
просто заставляет сопровождающего программиста шарить по листингу взглядом, ища while, вместо того, чтобы найти его сразу в случае расположения оператор while (1) в начале цикла.
61. В цикле со счетчиком его значение должно по возможности уменьшаться.
Циклы являются одним из тех мест, где малое повышение эффективности значительно улучшает выполнение программы, потому что их код выполняется многократно. Так как сравнение с нулем обычно более эффективно, чем сравнение с определенным числом, то цикл с уменьшающимся счетчиком, как правило, выполняется быстрее. Используйте
for ( i = max; --i >= 0; );
вместо: for ( i = 0; i ? max; ++i );
Заметьте, что в обоих случаях счетчики могут быть использованы в качестве действительного индекса массива, что может сделать этот код менее подверженным ошибкам вследствие того, что он ограничивает доступ к массиву его границами.
62. Не делайте одно и то же двумя способами одновременно.
В качестве контрапункта к предыдущему правилу рассмотрим следующий фрагмент (содержащий в себе ошибку):
int array[ARRAY_SIZE];int *p = array;
for ( i = 1; i ? ARRAY_SIZE ; ++i )
*p++ = 0;
Проблема состоит в том, что счетчик не совпадает по фазе с указателем (i имеет значение 1, когда указатель указывает на элемент array[0]), и последний элемент массива не будет инициализирован.Я обычно предпочитаю для простых перемещений по массивам указатели (вместо индексов массива), потому что указатели, как правило, более эффективны, устраняя неявную операцию умножения в выражении a[i], интерпретируемом как:
( a + ( i* sizeof(a[0])))Я бы переписал это код таким образом: int array[ARRAY_SIZE];int *current = array;
int *const end = array + (SIZE-1);
while ( current ?= end )
*current++ = 0;
Так же надежно (хотя и менее эффективно) сделать следующее: int array[ARRAY_SIZE];int i;
for ( i = 0; i ? ARRAY_SIZE ; ++i )
array[i] = 0;
Кстати, если вы используете указатели, то вам придется извлекать индекс при помощи арифметики указателей, а не за счет сохранения второй переменной. У вас могут возникнуть проблемы, если вы передадите i функции в предыдущем примере с ошибкой. Воспользуйтесь подобным кодом: for ( current = array; current ?= end; ++current ){
// ...
f( current - array ); // передать функции f() текущий индекс массива
}
С другой стороны, обычно нужно избегать кода, подобного следующему, так как такой оператор цикла чрезвычайно неэффективен: while ( (current - array) ? ARRAY_SIZE )// ...
63. Используйте оператор for, если имеются любые два из инициализурующего, условного или инкрементирующего выражений.
Иначе используйте while. Такой код:
int x = 10;// далее следует 200 строк кода, в которых переменная x не используется
while ( x > 0 )
{
// снова следует 200 строк кода
f( x-- );
}
не очень хорош, даже если вы сэкономили немного времени, соединив операцию декрементирования -- с вызовом функции. Переместите инициализацию и x-- в оператор for. Так как объявление в С++ может располагаться везде, где можно поместить оператор, то вы даже можете объявить x непосредственно перед for: int x = 10;for ( ; x > 0 ; --x )
{
// следует 200 строк кода
f(x);
}
(И хотя вы можете сказать, что в С++ есть возможность сделать for ( int=0;..., такая практика вводит в заблуждение, потому что на самом деле область видимости у x внешняя, как если бы ее объявление было сделано в строке, предшествующей оператору for. Я не рекомендую этого).Если три оператора внутри for слишком длинны, чтобы поместиться в одной строке, то вы можете их отформатировать их следующим образом:
for ( некое_длинное_имя_переменной = f();некое_длинное_имя_переменной ;
некое_длинное_имя_переменной = f() )
{
// ...
}
но часто лучше выделить одно из предложений вот так: int некое_длинное_имя_переменной = f();for ( ; некое_длинное_имя_переменной ; некое_длинное_имя_переменной = f() )
{
// ...
}
или в чрезвычайном случае int некое_чрезвычайно_длинное_имя_переменной = f();for ( ; ; некое_чрезвычайно_длинное_имя_переменной = f() )
{
if ( !некое_чрезвычайно_длинное_имя_переменной )
break;// ...}
Главное - это сосредоточить инициализацию, проверку и инкрементирование в одном месте. Я никогда не сделаю так: int некое_чрезвычайно_длинное_имя_переменной = f();while ( некое_чрезвычайно_длинное_имя_переменной )
{
// много строк кода
некое_чрезвычайно_длинное_имя_переменной = f();
}
потому что это нарушает контроль над циклом.
64. То, чего нет в условном выражении, не должно появляться и в других частях оператора for.
Так как оператор for предназначен для того, чтобы собрать инициализирующую, условную и инкрементирующие части цикла в одном месте, так чтобы вы могли, взглянув, понять, что происходит, то вы не должны загромождать оператор for материалом, который не имеет отношения к циклу, иначе вы лишите смысла всю эту конструкцию. Избегайте подобного кода:
int *ptr;// ...
for ( ptr = array, i = array_size; --i >= 0; f(ptr++) )
;
который лучше сформулировать так: int *ptr = array;for ( i = array_size; --i >= 0 ; )
f( ptr++ );
65. Допускайте, что ситуация может измениться в худшую сторону.
Одним из лучших примеров этой проблемы связан со "знаковым расширением". Большинство компьютеров используют так называемую арифметику "двоичного дополнения". Крайний левый бит отрицательного числа в этой арифметике всегда содержит 1. Например, восьмибитовый тип char со знаком, содержащий число -10, будет представлен в машине с двоичным дополнением как 11110110 (или 0xf6). То же самое число в 16-битовом типе int представлено как 0xfff6. Если вы преобразуете 8-битовый char в int явно посредством оператора приведения типов или неявно, просто используя его в арифметическом выражении, где второй операнд имеет тип int, то компилятор преобразует char в int, добавляя второй байт и дублируя знаковый бит (крайний слева) char в каждом бите добавленного байта. Это и есть знаковое расширение.
Существуют два вида операций сдвига вправо на уровне языка ассемблера: "арифметический сдвиг" дает вам знаковое расширение (то значение, что было в крайнем левом бите до сдвига, будет в нем и после сдвига); "логический сдвиг" заполняет левый бит нулем. Данное правило, независимо от того, арифметический или логический сдвиг у вас, когда вы используете оператор сдвига С/С++, звучит очень просто: если вам требуется знаковое расширение, то допустите, что у вас получится заполнение нулями. А если вам нужно заполнение нулями, то представьте, что у вас получилось знаковое расширение.
Другим хорошим примером являются возвращаемые коды ошибок. Удивительное количество программистов не заботится о проверке того, не вернула ли функция malloc() значение NULL при недостатке свободной памяти. Быть может, они полагают, что имеется бесконечный объем виртуальной памяти, но известно, что ошибка может с легкостью вызвать резервирование всей имеющейся памяти, и вы никогда не обнаружите этого, если не будете проверять возвращаемые коды ошибок. Если функция может индицировать состояние ошибки, то вы должны допустить, что ошибка произойдет по меньшей мере однажды за время жизни программы.
66. Компьютеры не знают математики.
Компьютеры - это арифметические инструменты, славные счетные машины. Они не знают математики. Поэтому даже такие простые выражения, как следующее, могут добавить вам хлопот:
int x = 32767;x = (x * 2) / 2;
(На 16-разрядной машине x получится равным -1. 32767 - это 0x7fff. Умножение на 2 - на самом деле сдвиг влево на один бит, дает в результате 0xfffe - отрицательное число. Деление на два является арифметическим сдвигом вправо с гарантированным знаковым расширением, и так вы получаете теперь 0xffff или -1). Поэтому важно каждый раз при выполнении арифметических вычислений учитывать ограничения компьютерной системы. Если вы производите умножение перед делением, то при этом рискуете выйти за пределы разрядности при сохранении результата; если вы сначала делите, то рискуете случайно округлить результат до нуля; и так далее. Численным методам для компьютеров посвящены целые книги, и вам нужно прочитать хотя бы одну из них, если в ваших программах много математики.Вы также должны знать мелкие грехи своего языка программирования. В С, например, преобразование типов выполняется по принципу "оператор за оператором". Я однажды потратил утро, пытаясь разобраться, почему следующий код ничего не делает:
long x;x ?= 0xffff; // очистить все, кроме младших 16-ти бит 32-битного типа long.
Компьютер имел 16-битовый тип int и 32-битовый тип long. Константа 0xffff типа int с арифметическим значением -1. Компилятор С при трансляции ?= обнаруживал разные типы операндов и поэтому преобразовывал int в long. -1 в типе long представляется как 0xffffffff, поэтому логическая операция И не имела эффекта. Это как раз тот способ, которым и должен работать данный язык программирования. Я просто об этом не подумал.Заметьте, что вы не можете исправить эту ситуацию приведением типов. Все, что делает следующий код, это заменяет неявное преобразование типа явным. Но тем не менее происходит то же самое:
x ?= (long)0xffff;Единственным методом решения этой проблемы является: x ?= 0xffffUL;или равноценный ему.
66.1. Рассчитывайте на невозможное.
Оператор switch всегда должен иметь предложение с ключевым словом default для ситуации по умолчанию, особенно если эта ситуация не должна возникать:
f( int i ) // переменная i должна иметь значение 1 или 2.{
switch( i )
{
case 1: сделать_нечто(); break;
case 2: сделать_нечто_другое(); break;
default:
fprintf(stderr, "Внутренняя ошибка в f(): неверное значение i (%d)", i );exit( -1 );
}}
То же самое относится к блокам if/else, работающим в манере, схожей с оператором switch.В цикле также нужна проверка на невероятное. Следующий фрагмент работает, даже если i первоначально равно 0 - чего по идее быть не должно:
f( int i ) // переменная i должна быть положительной{
while ( --i >= 0 )
сделать_нечто();
}
Конструкция while(--i) менее надежна, так как она дает ужасный сбой в случае, если i сначала равно 0.66.2. Всегда проверяйте код, вызывающий ошибку.
Это должно быть очевидно, но комитет ISO/ANSI по С++ потребовал, чтобы оператор new вызывал исключение, если он не смог выделить память, потому что было установлено, что удивительное множество ошибок во время выполнения в реальных программах вызвано тем, что люди не потрудились проверить, не возвратил ли new значение NULL.
Мне также довелось видеть множество программ, в которых люди не позаботились посмотреть, сработала ли функция fopen(), перед тем как начать пользоваться указателем FILE.
67. Избегайте явно временных переменных.
Большинство переменных, используемых лишь один раз, попадают в эту категорию. Например, вместо:
int x = *p++;f( x );
должно быть: f( *p++ );Редко бывает, что полезна явная временная переменная, если вам нужно гарантировать порядок вычислений, или если выражение просто такое длинное, что его невозможно прочитать. В последнем случае имя переменной даст полезную информацию и, будучи выбрано правильно, может устранить необходимость в комментарии. Например, вы можете заменить: f( Coefficient_of_lift * (0.5 * RHO * square(v)) ); // передать функции f() образующуюся// подъемную силу
f( Коэффициент_подъемной_силы * (0.5 * RHO * квадрат(v)) ); // передать функции f()
// образующуюся подъемную
// силу
на: double lift = Coefficient_of_lift * (0.5 * RHO * square(v));f( lift );
double подъемная_сила = Коэффициент_подъемной_силы * (0.5 * RHO * квадрат(v));
f( подъемная_сила );
Это правило не запрещает ни одно из подобных применений, а является, скорее, вырожденным случаем того, что упомянуто мной вначале.
68. Не нужно магических чисел.
В основном тексте вашей программы не должно быть чисел в явном виде. Используйте перечислитель или константу для того, чтобы дать числу символическое имя. (Я уже объяснял, почему для этого не очень хорошо применять #define). Тут есть два преимущества:
- Символическое имя делает величину самодокументируемой, устраняя необходимость в комментарии.
- Если число используется более чем в одном месте, то менять нужно лишь одно место - определение константы.
{
char buf[128]
...
fgets( buf, sizeof (buf) / sizeof(*buf), stdin );
}
Я использовал sizeof() в вызове fgets(), поэтому изменения размера массива автоматически отражаются в программе. Добавление дополнительного идентификатора для хранения размера добавит излишнюю сложность.
69. Не делайте предположений о размерах.
Классической проблемой является код, исходящий из того, что тип int имеет размер 32 бита. Следующий фрагмент не работает, если у вас 32-битный указатель и 16-битный тип int (что может быть при архитектуре Intel 80x86):
double a[1000], *p = a;// ...
dist_from_start_of_array_in_bytes = (int)p - (int)a;
расстояние_от_начала_массива_в_байтах = (int)p - (int)a;
Более трудно уловима такая проблема в С (но не в С++): g(){
не_работает( 0 );
}
не_работает( char *p )
{
if( !p ) // вероятно не работает
// ...}Компилятор соглашается с этим вызовом, потому что в С разрешены ссылки вперед (и не разрешены в С++, так что там это не проблема). 0 это тип int, поэтому в стек помещается 16-битовый объект. Но функция ожидает 32-битный указатель, поэтому она использует 16 бит из стека и добавляет к ним еще 16 бит всякого мусора для создания 32-битного указателя. Вероятнее всего, что if( !p ) даст ложный результат, так как только 16 бит из 32 будут равны 0.Традиционное решение состоит в использовании typedef :
typedef int word; // всегда 16 битtypedef long dword; // всегда 32 бита.
После чего вы можете поменять операторы typedef в новой операционной среде, чтобы гарантировать, что word по прежнему имеет размер 16 бит, а dword - 32 бита. Для 32-разрядной системы предыдущее может быть переопределено как: typedef short word; // всегда 16 битtypedef int dword; // всегда 32 бита.
Другая связанная с размерностью часовая бомба спрятана в том способе, которым в ANSI С обеспечивается работа с иностранными языками. ANSI С определяет тип wchar_t для работы с расширенными наборами символов типа Unicode - нового 16-битного многонационального набора символов. Стандарт ANSI С также утверждает, что перед строкой с расширенными символами должен стоять символ L. Micrisoft и другие поставщики компиляторов стараются помочь вам писать переносимые программы, предусматривая макросы типа: #ifdef _UNICODEtypedef wchar_t _TCHAR
# define _T(x) L##x
#else
typedef char _TCHAR
# define _T(x) x
#endif
Если константа _UNICODE не определена, то оператор: _TCHAR *p = _T("делай_что_нужно");имеет значение: char *p = "делай_что_нужно";Если константа _UNICODE определена, тот же самый оператор получает значение: wchar_t *p = L"делай_что_нужно";Пока все хорошо. Вы теперь можете попробовать перенести вашу старую программу в среду Unicode, просто используя свой редактор для замены всех экземпляров char на _TCHAR и помещения всех строковых констант в скобки _T(). Проблема состоит в том, что такой код, как ниже (в котором все _TCHAR первоначально были типа char), более не работает: _TCHAR str[4];// ...
int max_chars = sizeof(str); // предполагает, что тип char имеет размер 1 байт
Тип _TCHAR будет иметь размер 2 байта при определенной константе _UNICODE, поэтому число символов у вас будет определено в два раза большим, чем есть на самом деле. Для исправления ситуации вы должны воспользоваться следующим вариантом: int max_chars = sizeof(str) / sizeof(*str) ;
70. Опасайтесь приведения типов (спорные вопросы С).
Оператор приведения типов часто понимается неправильно. Приведение типов не указывает компилятору "считать эту переменную принадлежащей к этому типу". Оно должно рассматриваться как операция времени выполнения, которая создает временную переменную типа, определенного для приведения, затем инициализирует эту временную переменную от операнда. В С++, конечно, эта инициализация может обернуться очень большими накладными расходами, так как возможен вызов конструктора.
Первое место, где неверное понимание приведения типов может навлечь на вас неприятности, находится в С, где не требуются прототипы функций. Когда компилятор находит вызов функции без предшествующего прототипа, то полагает, что эта функция возвращает тип int. В следующем фрагменте не говориться "malloc() на самом деле возвращает указатель, а не тип int":
int *p = (int *) malloc( sizeof(int) );а скорее код говорит "я полагаю, что malloc() возвращает тип int, так как тут нет предшествующего прототипа, и преобразую этот int в указатель для присваивания его значения p). Если тип int имеет размер 16 бит, а указатель 32-битовый, то вы теперь в глубокой луже. Вызов malloc() может вернуть и 32-битовый указатель, но так как компилятор полагает, что malloc() возвращает 16-битовый int, то он игнорирует остальные 16 бит. Затем компилятор округляет возвращенное значение до 16-бит и преобразует его в 32-битовый тип int принятым у него способом, обычно заполняя старшие 16 бит нулями. Если указатель содержал адрес больше, чем 0xffff, что вероятно для большинства компьютеров, то вы просто теряете старшие биты. Единственным способом урегулирования этой проблемы является указание для malloc() соответствующего прототипа, который подскажет, что malloc() возвращает указатель (обычно путем включения файла ?stdlib.h>).Следующий проблема состоит в том, что предыдущее приведение типа может быть вставлено в программу просто для того, чтобы заставить заткнуться компилятор, который наверняка будет выдавать предупреждение о несоответствии типов, если оператор приведения отсутствует. Приведением типов часто злоупотребляют подобным образом - чтобы заглушить компилятор, вместо того чтобы в самом деле обратить внимание на предупреждение. Многие компиляторы, например, выдают предупреждение о возможном округлении, встретив следующий код:
f( int x );// ...
unsigned y;
f( y );
и многие программисты заглушат такой компилятор при помощи f((int)y). Несмотря на это, приведение типа не изменит того факта, что тип unsigned int может содержать такое значение, которое не поместится в int со знаком, поэтому результирующий вызов может не сработать.Вот сходная проблема, связанная с указателями на функции. Следующий код, случается, работает отлично:
some_object array[ size ];int my_cmp( some_object *p1, some_object *p2 );
qsort( array, size, sizeof(some_object), ((*)(void*, void*)) my_cmp );
Следующий похожий код просто печально отказывается работать без предупреждающего сообщения: some_object array[ size ];void foo( int x );
qsort( array, size, sizeof(some_object), ((*)(void*, void*)) foo );
Функция qsort() передает аргументы-указатели в foo(), но foo() ждет в качестве аргумента int, поэтому будет использовать значение указателя в качестве int. Дальше еще хуже - foo() вернет мусор, который будет использован qsort(), так как она ожидает в качестве возвращаемого значения int.Выравнивание также связано с затруднениями. Многие компьютеры требуют, чтобы объекты определенных типов располагались по особым адресам. Например, несмотря на то, что 1-байтоый тип char может располагаться в памяти по любому адресу, 2-байтовый short должен будет иметь четный адрес, а 4-байтовый long - четный и кратный четырем. Следующий код вновь не выдаст предупреждений, но может вызвать зависание компьютера во время выполнения:
short x;long *lp = (long*)( ?x );
*lp = 0;
Эта ошибка особенно опасна, потому что *lp = 0 не сработает лишь тогда, когда x окажется по нечетному или не кратному четырем адресу. Может оказаться, что этот код будет работать до тех пор, пока вы не добавите объявление второй переменной типа short сразу перед x, после чего эта программа зависнет.Один из известных мне компиляторов пытается справиться с этой проблемой фактически модифицируя содержимое указателя для того, чтобы гарантировать правильный адрес в качестве побочного эффекта от приведения типа. Другими словами, следующий код мог бы на самом деле модифицировать p:
p = (char *)(long *);
71. Немедленно обрабатывайте особые случаи.
Пишите свои алгоритмы таким образом, чтобы они обрабатывали вырожденные случаи немедленно. Вот тривиальный пример того, как сделать это неправильно:
print( const char *str ){
if ( !*str ) // ничего не делать, строка пуста return;while ( *str ) putchar( *str++ );}Оператор if тут не нужен, потому что этот случай хорошо обрабатывается циклом while.Листинги 2 и 3 демонстрируют более реалистический сценарий. Листинг 2 определяет умышленно наивный заголовок связанного списка и функцию для удаления из него элемента.
Листинг 2. Связанный список: Вариант 1.
- typedef struct node
- {
- struct node *next, *prev;
- //...
- } node;
- node *head;
- remove( node **headp, node *remove )
- {
- // Удалить элемент, на который указывает "remove", из списка, на начало
- // которого указывает *headp.
- if ( *headp == remove ) // Этот элемент в начале списка.
- {
- if ( remove->next ) // Если это не единственный элемент в списке,
- remove->next->prev = NULL; // то поместите следующий за ним элемент
- // первым в списке.
- *headp = remove->next;
- }
- else // Элемент находится в середине списка
- {
- remove->prev->next = remove->next;
- if ( remove->next )
- remove->next->prev = remove->prev;
- }
- }
Смысл этого состоит в том, что незначительная переделка этой задачи позволяет мне использовать алгоритм, не имеющий особых случаев, этим самым упрощая программу. Конечно, эта простота не дается бесплатно - теперь стало невозможным перемещение по списку в обратном направлении - но нам ведь это может быть и не нужно.
Листинг 3. Связанный список: Вариант 2.
- typedef struct node
- {
- struct node *next, **prev; // ?=== К prev добавлен символ *
- // ...
- } node;
- node *head;
- remove( node **headp, node *remove )
- {
- if ( *(remove->prev) = remove->next ) // если не в конце списка,
- remove->next->prev = remove->prev; // то уточнить следующий элемент
- }
72. Не старайтесь порадовать lint.
Lint является программой проверки синтаксиса для языка С. (Также имеется версия для С++ в среде MS-DOS/Windows. Она выпускается фирмой Gimple Software). Хотя эти программы неоценимы при использовании время от времени, они выводят такую кучу сообщений об ошибках и предупреждений, что текст вашей программы будет почти невозможно прочитать, если вы попробуете избавиться от всех них. Оказывается, нужно избегать кода, подобного следующему:
(void ) printf("...");Тут вообще нет ничего неверного в присваивании в цикле: while ( p = f() )g(p);
даже если новичок в программировании может воспользоваться символом = вместо ==. (Проблемы новичков не должны приниматься во внимание, когда вы обсуждаете рекомендуемый стиль для опытных профессионалов. Это похоже на принятие закона, который требует, чтобы все велосипеды оснащались боковыми колесиками, потому что двухлетним малышам без них тяжело кататься).Я читал предложение поручать компилятору поиск небрежных присваиваний (когда вы на самом деле подразумевали сравнение) просто размещая константы в левой части. Например, следующий фрагмент даст ошибку при компиляции, если вы используете = вместо ==:
#define MAX 100// ...
if ( MAX == x )
// ...
В этой идее есть достоинства, но я нахожу, что такой код труднее читается.
73. Помещайте код, динамически распределяющий и освобождающий память, в одном и том же месте.
Утечки памяти - выделенную память забыли освободить- являются большой проблемой в приложениях, продолжительность работы которых не ограничена: серверах баз данных, торговых автоматах, операционных системах и так далее. Имеется множество способов для того, чтобы отслеживать эту проблему. Многие программы, например, модифицируют функцию malloc() для создания списка выделенных областей памяти, который может просматриваться функцией free() для проверки задействованных указателей. Вы также можете доработать заголовочный файл, необходимый для сопровождения списка выделенных областей памяти, путем помещения туда информации о том, откуда было произведено выделение памяти. (Передайте __LINE__ и _FILE__ в свою отладочную версию malloc()). Список выделенных областей памяти должен быть пуст при завершении работы программы. Если он не пуст, то вы можете его просмотреть и, по крайней мере, разобраться, где была выделена эта память.
Отслеживание - это хорошо, но предупреждение лучше. Если есть возможность, то вы должны размещать free() в той же функции, где сделан соответствующий вызов malloc(). Например, используйте это:
void user( void ){
p = malloc( size );
producer( p );
consumer( p );
free( p );
}
void пользователь( void )
{
p = malloc( size );
изготовитель( p );
потребитель( p );
free( p );
}
вместо этого:void *producer( )
{
void *p = malloc( size );
// ...
return p;
}
void consumer( void *p )
{
// ...
free( p );
}
void user( void )
{
void *p = producer();
consumer( p );
}
void *изготовитель( )
{
void *p = malloc( size );
// ...
return p;
}
void потребитель( void *p )
{
// ...
free( p );
}
void пользователь( void )
{
void *p = изготовитель();
потребитель( p );
}
Несмотря на это, вы не сможете всегда делать подобное на С. Например, предыдущие правила о неинициализированных переменных относятся и к памяти, выделенной malloc(). Лучше сделать так:
some_object *p = allocate_and_init(); // Не возвращает значения, если // памяти недостаточно.некий_объект *p = выделить_и_инициализировать(); // Не возвращает значения, еслипамяти недостаточно. чем так: some_object *p = malloc( sizeof(some_object) );
if ( !p )
fatal_error("Недостаточно памяти!");init();некий_объект *p = malloc( sizeof(некий_объект) );
if ( !p )
фатальная_ошибка("Недостаточно памяти!");инициализировать();В С++ эта проблема решается при помощи конструкторов.
74. Динамическая память - дорогое удовольствие.
Следующей основной проблемой при использовании malloc()/ free() (или new/delete) является время, требуемое для управления памятью; оно может быть значительным. Я однажды сократил время выполнения на 50% путем замены многочисленных вызовов malloc() и free() на другую стратегию. Например, если у вас есть очень активно используемая структура из одинаковых объектов, то вы можете использовать нечто подобное коду из листинга 4 для управления членами структуры данных.
Листинг 4. Управление собственным списком высвобожденных элементов.
- typedef struct some_class
- {
- struct some_class *next;
- //...
- }
- some_class;
- static some_class *free_list = NULL;
- //-------------------------------------------------------------------------------------------------------------------------------------------
- free_object( some_class *object )
- {
- // Вместо того, чтобы передать память из-под объекта функции free(),
- // свяжите ее с началом списка высвобожденных элементов.
- object->next = free_list;
- free_list = object;
- }
- //-------------------------------------------------------------------------------------------------------------------------------------------
- free_all_objects( )
- {
- // Высвободить все объекты в список высвобожденных элементов. Сортировка
- // этих объектов по базовому адресу перед началом цикла улучшит скорость работы
- // по освобождению, но я не делаю здесь этого. (Для сортировки связанных
- // списков превосходно подходит алгоритм Quicksort).
- some_object *current;
- while ( free_list )
- {
- current = free_list;
- free_list = current->next;
- free( current );
- }
- }
- //-------------------------------------------------------------------------------------------------------------------------------------------
- some_class *new_object( )
- {
- // Если в списке высвобожденных элементов имеется объект, то используйте
- // его. Размещайте объект посредством malloc(), только если список
- // высвобожденных объектов пуст.
- some_class *object;
- if ( free_list )
- {
- object = free_list; // передайте память для объекта
- free_list = object->next;
- }
- else
- {
- // Вы можете улучшить производительность еще более, если будете
- // размещать объекты в памяти по 100, а не по 1 за раз, но это усложнит
- // функцию free_all_objects().
- object = malloc( sizeof(some_class) );
- }
- if ( object )
- // поместите здесь инициализирующий код
- return object;
- }
75. Тестовые подпрограммы не должны быть интерактивными.
Мне часто показывают тестовые программы, имеющие усовершенствованный интерактивный интерфейс пользователя. Это не только является пустой тратой времени, но и не может быть использовано для тщательного тестирования. Люди, сидящие за клавиатурами и пробующие все, что им приходит в голову, недостаточно методичны. Поэтому для систематического выполнения функций, подлежащих проверке, лучше использовать неинтерактивную тестовую функцию.
И, кстати, не удаляйте эту тестовую процедуру; просто используйте предложение #ifdef TEST для включения или выключения этой подпрограммы из компиляции. Если вы похожи на меня, то вы утром удалите эту тестовую функцию, а уже к обеду она вам понадобиться снова, даже если вы не пользовались ей последние два года.
76. Сообщение об ошибке должно подсказывать пользователю, как ее исправить.
Когда-то, во времена CP/M, отладчик DDT имел единственное сообщение об ошибке. Не имело значения, что вы натворили, он всегда говорил:
?Несмотря на то, что подобная обработка ошибок, к счастью, больше не является нормой, я все еще вижу ее, хотя и с более прихотливыми украшениями. Несколько программ для Windows, мне принадлежащие, просто издают звуковой сигнал, когда я ввожу неверное значение в диалоговом меню, заставляя меня гадать, какое же значение верное. Я часто видел сообщения об ошибках, которые давали мне обильное количество информации о том, что я сделал неправильно, не давая подсказки, как это делается правильно. В самой печальной ситуации диалоговое меню предлагает вам ввести число, но когда вы вводите неверное число, оно выводит такое сообщение: Неверное значение.без намека на то, какое значение будет верным. Иногда диалоговое меню отказывается закрыться до тех пор, пока вы не введете верное значение. Иногда программа захватывает управление компьютером, и вы не можете переключиться в другое приложение, завершив то, в котором с вами случилась беда. (В Windows это "свойство" называется системно-модальным диалоговым меню. Пожалуйста, не пользуйтесь им). И вот вы перед выбором: завершить программу, нажав Ctrl-C или ее эквивалент (если можете), отключить питание или наобум набирать числа на клавиатуре до тех пор, пока вам не удастся наткнуться на то, которое удовлетворит программу ввода данных. Вопрос состоит в том, что займет у вас больше времени: повторить последние три часа работы, которую вы не подумали сохранить перед вызовом диалогового меню, или потратить еще три часа, играя в "холодно-горячо" с диалоговым меню. Это как раз та ситуация, из-за которой у компьютеров дурная слава.Сообщение об ошибке должно подсказывать вам, как исправить эту ситуацию, что-нибудь типа:
Числа должны быть в диапазоне от 17 до 63 включительно.или: Даты должны иметь формат дд-мм-гггг.Должен быть какой-то способ (типа клавиши "help/cправка") для получения дополнительной информации, если она вам нужна. Наконец, у вас должен быть способ безопасного прекращения процесса ввода данных (типа клавиши "Выход").
77. Не выводите сообщения об ошибке, если она исправима.
Библиотечные подпрограммы (и большинство подпрограмм на языках низкого уровня) не должны выводить сообщений об ошибках. Они должны возвращать код ошибки, который может быть проверен вызывающей подпрограммой. Таким способом эта подпрограмма может предпринять какие-то корректирующие действия. Например, если рекурсивная функция-сортировщик сообщила об ошибке, выйдя за пределы стека, то вызвавшая ее подпрограмма не сможет попытаться заново выполнить сортировку с использованием другого, нерекурсивного алгоритма. Пользователь должен увидеть сообщение об ошибке, даже если вторая попытка сортировки будет удачной.
78. Не используйте системно-зависимых функций для сообщений об ошибках.
Многие среды с оконным интерфейсом не поддерживают понятия стандартного устройства для вывода или для сообщений об ошибках. (В этих средах вызовы printf() или fprintf(stderr, ...) обычно игнорируются). Если вы будете основываться на догадках о своей среде, то обнаружите, что вам необходимы значительные доработки просто для того, чтобы перекомпилировать код для новой среды).
Минимум вашей защиты может быть таким:
#define ошибка printf#define завершить(x) ExitProcess(x)
после чего используйте: if ( некая_ошибка ){
ошибка("Тут что-то не так ");завершить( -1 );
}Вот более гибкое решение:#include ?stdio.h>
#include ?sdarg.h>
#ifdef WINDOWS
void error( const char* format, ... )
{
char buf[255]; // надеемся, что такой размер будет достаточенva_list args;
va_start( args, format );
if ( vsprintf( buf, format, args ) ? sizeof(buf) )
::MessageBox(NULL, buf, "*** ОШИБКА ***", MB_OK | MB_ICONEXCLAMATION );else{
::MessageBox(NULL, "Переполнение буфера при печати сообщения об ошибке.", "Фатальная ошибка",MB_OK | MB_ICONEXCLAMATION );
ExitProcess( -1 );}va_end( args );
}#elif MOTIF
// Здесь следует функция обработки ошибки, используемая в ОС Motif#else void error( const char* format, ... ){
va_list args;va_start( args, format );
vfprintf(stderr, format, args );
va_end ( args );
}#endif
Глава 6. Препроцессор
Многие свойства языка С++ делают препроцессор С менее важным, чем он был по традиции. Тем не менее, препроцессор иногда нужен даже в программе на С++ и, естественно, остается неотъемлемой частью программирования на С. Правила в этой главе книги посвящены правильному использованию препроцессора.Я должен сказать, что многие из тех макросов, которые мне пришлось видеть, имеют довольно сомнительные основы с точки зрения удобочитаемости и сопровождения. Я часто предпочитаю не пользоваться макросом, если эквивалентная функция сделает ту же самую работу в более удобочитаемой манере, и никогда не хочу использовать макрос, вызывающий побочный эффект (будет рассмотрено ниже). В С++ я никогда не пользуюсь макросами с параметрами, используя вместо них встроенные (inline) функции или шаблоны, которые расширяются компилятором до встроенных функций. Макрос с параметрами даже в языке С должен быть методом, используемым лишь в крайнем случае. В макросах трудно обнаруживать ошибки (так как они не выполняется в пошаговом режиме), часто тяжело читать и, в лучшем случае, сложно сопровождать. Используйте их лишь тогда, когда скорость выполнения действительно является критерием, подтверждаемым фактическим тестированием кода с их использованием. Таким образом, эта глава книги содержит правила для тех случаев, где препроцессор является единственным решением проблемы.
79. Все из одного .h файла должно быть использовано в по меньшей мере двух .c файлах.
Это правило говорит само за себя - не загромождайте область глобальных имен идентификаторами, которые не используются глобально. Если идентификатор не используется вне текущего файла, то он должен объявляться лишь в области действия текущего файла. Если этот не используемый совместно идентификатор является глобальной переменной или функцией, то он должен быть объявлен статическим.
Заметьте, что статические функции находят применение даже в С++. Имеется тенденция помещать все основные функции, используемые любым из обработчиков сообщений, в собственно определение класса. Иногда локальная статическая функция в файле .cpp делает эту работу так же хорошо, и нет нужды загромождать прототипом этой функции определение класса.
80. Используйте вложенные директивы #include.
Хотя большинство из правил в этой главе говорят вам, как избежать использования препроцессора, механизм включения файлов директивой #include является обязательной функцией препроцессора как в С, так и в С++. Тем не менее, даже здесь существуют проблемы.
Это на самом деле плохая идея - требовать, чтобы кто-нибудь включал файл, способный включать в себя следующий. Я всегда располагаю директивы #include без определенного порядка или забываю вставить одну из них. Следовательно, заголовочный файл должен всегда включать те файлы, которые определяют то, что используется в текущем заголовочном файле. Вследствие того, что могут возникнуть проблемы, если компилятор прочитает какой-нибудь .h файл более одного раза, вы должны предпринять шаги для предотвращения многократной обработки одного и того же файла. Помещайте строки типа:
#ifndef FILENAME_H_#define FILENAME_H_
в начале каждого заголовочного файла, и вставляйте соответственно: #endif // FILENAME_H_в конце. Так как константа FILENAME_H_ будет уже определена к моменту второй попытки препроцессора обработать этот файл, то его содержание при втором проходе будет проигнорировано.
81. Вы должны быть всегда способны заменить макрос функцией.
Это вариант для макросов правила "не нужно неожиданностей (без сюрпризов)". Что-то, похожее внешне на функцию, должно действовать подобно функции, даже если это на самом деле макрос. (По этой причине я иногда предпочитаю записывать имя макроса заглавными буквами не полностью, если его поведение сильно напоминает функцию. Хотя я всегда использую все заглавные, если у макроса есть побочные эффекты). При этом возникает насколько вопросов.
Во-первых, макрос не должен использовать переменные, не передаваемые в качестве аргументов. Вот наихудший из возможных способов в таких обстоятельствах:
Следующий код находится в заголовочном файле:
#define end() while (*p) \ ++pа этот - в файле .c: char *f( char *str ){
char *p = str;
end();
// ...
return p;
}
Здесь для сопровождающего программиста имеется несколько неприятных сюрпризов. Во-первых, переменная p явно не используется, поэтому появляется искушение стереть ее, разрушая этим код. Аналогично, программа разрушится, если имя p будет заменено другим. Наконец, будет большой неожиданностью то, что вызов end(), который выглядит внешне как вызов обычной функции, будет модифицировать p.Первая попытка урегулирования этой проблемы может выглядеть следующим образом. В заголовочном файле:
#define end(p) while (*p) \ ++pи в файле .c: char *f( char *str ){
end(str);// ...
return str;
}Но теперь макрос все еще необъяснимо модифицирует str, а нормальная функция С не может работать таким образом. (Функция С++ может, но не должна. Я объясню почему в той главе книги, которая посвящена С++). Для модификации строки str в функции вы должны передать в нее ее адрес, поэтому то же самое должно быть применимо к макросу. Вот третий (наконец-то правильный) вариант, в котором макрос end() попросту заменен функцией с таким же именем. В заголовочном файле: #define end(p) while (*(*p)) \ ++(*p)и в файле .c: char *f( char *str ){
end(?str);// ...
return str;
}Вместо end(?str) будет подставлено: while (*(*?p)) ++(*?p)и *?p - это то же самое, что и p, так как знаки * и ? отменяют друг друга - поэтому макрос в результате делает следующее: while (*(p)) ++(p)Вторая проблема с макросом в роли функции возникает, если вы желаете выполнить в макросе больше, чем одно действие. Рассмотрим такой макрос: #define две_вещи() a();b()if ( x )
две_вещи();else нечто_другое();который будет расширен следующим образом (тут я переформатировал, чтобы сделать происходящее неприятно очевидным): if ( x ) a();b();else
нечто_другое();Вы получаете сообщение об ошибке "у else отсутствует предшествующий оператор if". Вы не можете решить эту проблему, используя лишь фигурные скобки. Переопределение макроса следующим образом: #define две_вещи() { a(); b(); }вызовет такое расширение: if ( x ){
a();b();
};
else
нечто_другое();Эта вызывающая беспокойство точка с запятой - та, что следует после две_вещи() в вызове макроса. Помните, что точка с запятой сама по себе является законным оператором в С. Она ничего не делает, но она законна. Вследствие этого else пытается связаться с этой точкой с запятой, и вы получаете то же самое "у else отсутствует предшествующий оператор if".Не нужно говорить, что несмотря на то, что макрос выглядит подобно вызову функции, его вызов может не сопровождаться точкой с запятой. К счастью, для этой проблемы имеется два настоящих решения. Первое из них использует малоизвестный оператор "последовательного вычисления" (или запятую):
#define две_вещи() ( a(), b() )Эта запятая - та, что разделяет подвыражения в инициализирующей или инкрементирующей частях оператора for. (Запятая, которая разделяет аргументы функции, не является оператором последовательного вычисления). Оператор последовательного вычисления выполняется слева направо и получает значение самого правого элемента в списке (в нашем случае значение, возвращаемое b()). Запись: x = ( a(),b() );означает просто: a();x = b();
Если вам все равно, какое значение имеет макрос, то вы можете сделать нечто-подобное, используя знак плюс вместо запятой. (Выражение: a()+b();в отдельной строке совершенно законно для С, где не требуется, чтобы результат сложения был где-нибудь сохранен). Тем не менее при знаке плюс порядок выполнения не гарантируется; функция b() может быть вызвана первой. Не путайте приоритеты операций с порядком выполнения. Приоритет просто сообщает компилятору, где неявно размещаются круглые скобки. Порядок выполнения вступает в силу после того, как все круглые скобки будут расставлены по местам. Невозможно добавить дополнительные скобки к ((a())+(b())). Оператор последовательного вычисления гарантированно выполняется слева направо, поэтому в нем такой проблемы нет.Я должен также отметить, что оператор последовательного вычисления слишком причудлив, чтобы появляться в нормальном коде. Я использую его лишь в макросах, сопровождая все обширными комментариями, объясняющими, что происходит. Никогда не используйте запятую там, где должна быть точка к запятой. (Я видел людей, которые делали это, чтобы не использовать фигурные скобки, но это страшно даже пересказывать).
Второе решение использует фигурные скобки, но с одной уловкой:
#define две_вещи() \ do \{ \
a(); \b(); \
} while ( 0 )if ( x ) две_вещи();else нечто_другое();что расширяется до: if ( x ) do{
a();b();
} while ( 0 ) ; // ?== точка с запятой связывается с оператором while ( 0 )else нечто_другое();Вы можете также попробовать так: #define две_вещи() \ if ( 1 ) \{ \
a(); \b(); \
} elseно я думаю, что комбинация do с while (0) незначительно лучше.Так как вы можете объявить переменную после любой открытой фигурной скобки, то у вас появляется возможность использования предшествующего метода для определения макроса, имеющего по существу свои собственные локальные переменные. Рассмотрим следующий макрос, осуществляющий обмен значениями между двумя целочисленными переменными:
#define swap_int(x,y) \ do \{ \
int x##y; \x##y = x; \
x = y; \
y = x##y \
} \while (0)
Сочетание ## является оператором конкатенации в стандарте ANSI С. Я использую его здесь для обеспечения того, чтобы имя временной переменной не конфликтовало с любым из имен исходных переменных. При данном вызове: swap(laurel, hardy);препроцессор вначале подставляет аргументы обычным порядком (заменяя x на laurel, а y на hardy), давая в результате следующее имя временной переменной: int laurel##hardy;Затем препроцессор удаляет знаки решетки, давая int laurelhardy;Дополнительная польза от возможности замены макросов функциями заключается в отладке. Иногда вы хотите, чтобы что-то было подобно макросу по эффективности, но вам нужно при отладке установить в нем точку прерывания. Используйте для этого в С++ встроенные функции, а в С используйте следующие: #define _AT_LEFT(this) ((this)->left_child_is_thread ? NULL : (this)->left)#ifdef DEBUG
static tnode *at_left(tnode *this) { return _AT_LEFT(this); }#else# define at_left(this) _AT_LEFT(this)
#endif
Я закончу это правило упоминанием о еще двух причудливых конструкциях, которые иногда полезны в макросе, прежде всего потому, что они помогают макросу расширяться в один оператор, чтобы избежать проблем с фигурными скобками, рассмотренных ранее. Положим, вы хотите, чтобы макрос по возможности расширялся в единственное выражение. Оператор последовательного вычисления достигает этого за счет читаемости, и наряду с ним я никогда не использую формы, показанные в таблице 1, по той же причине - их слишком трудно читать. (Коли на то пошло, я также не использую их в макросах, если я могу достичь желаемого каким-то другим способом). Таблица 1. Макросы, эквивалентные условным операторам.| Этот код: | Делает то же самое, что и: |
| ( a ?? f() ) | if ( a ) f(); |
| ( b || f() ) | if ( !b ) f(); |
| ( z ? f() : g()) | if ( z ) f(); else g(); |
81.1. Операция ?: не то же самое, что и оператор if/else.
Последняя строка в таблице 1 относится к другому спорному вопросу. Условная операция - это простой оператор. Она используется лишь в выражении и передает значение. Условная операция является не очень привычной заменой для оператора if/else, но не менее, чем операции ?? или || приемлемы для замены простого if. Хотя большинство людей и не принимают во внимание замену:
if ( z ) i = j;else i = k;на: z ?? (i = j);z || (i = k);
Мне довелось случайно увидеть подобное этому, но с использованием условной операции: z ? (i = j) : (i = k) ;Все предыдущие фрагменты в равной мере способны сбить с толку. Следующий код показывает, как надлежащим образом использовать условную операцию, и ее результат яснее (т.е. лучше), чем у равноценного оператора if/else: i = z ? j : k ;81.2. Помещайте тело макроса и его аргументы в круглые скобки.
Это правило одно из основных, но я обнаружил, что множество людей, пользующихся С ежедневно, его забыли. Вот классическая задача:
#define TWO_K 1024 + 1024что при использовании в: 10 * TWO_Kрасширяется до: 10* 1024 + 1024вычисляемого как: (10 * 1024) + 1024Решаем эту задачу при помощи круглых скобок: #define TWO_K (1024 + 1024)Вот сходная задача в следующем фрагменте кода: #define SQUARE(x) (x * x)Определено: SQUARE(y + 1);что расширяется макросом до: y + 1 * y + 1и вычисляется как: y + (1 * y) + 1И вновь круглые скобки приходят на помощь. Следующее определение: #define SQUARE(x) ((x) * (x))расширяется до: ((y + 1) * (y + 1))
82. enum и const лучше, чем макрос.
Директива #define должна быть вашим последним средством при определении значения константы. Рассмотрим следующую рассмотренную ранее распространенную ошибку:
#define TWO_K 1024 + 1024x = TWO_K * 10
что в результате вычисления дает 11264 (1024+(1024*10)) вместо требуемых 20480. Определение перечисления типа: enum { two_k = 1024 + 1024 };или константы типа: const int Two_k = 1024 + 1024;не вызывает трудностей, связанных с макросом. И круглые скобки не требуются.Перечисление enum на несколько очков превосходит константу: во-первых, определение const int в языке С на самом деле выделяет память под тип int и инициализирует ее. Вы не можете модифицировать эту область памяти, но память при этом занята. Следовательно, определение константы в С нельзя поместить в заголовочном файле; вы нужно будет воспользоваться модификатором extern как для какой-нибудь глобальной переменной. (В С++ все это несущественно, так как там память выделяется лишь тогда, когда вы определяете адрес константы или передаете его по ссылке. Определения констант в С++ могут - а на деле часто и должны - помещаться в заголовочном файле).
Перечисление отличается тем, что память для него никогда не выделяется. Подобно макросу, оно может вычисляться во время компиляции. Следовательно, при использовании вами перечисления не происходит потери производительности.
Второй проблемой является порча области глобальных имен. Область действия перечисления легко ограничивается. Например, в следующем фрагменте кода перечисление default_i действует лишь внутри функции f():
void f( int i ){
enum { default_i = 1024 };if ( !i )
i = default_i ;}В фрагменте: void f( int i ){
#define DEFAULT_I 1024if ( !i )
i = DEFAULT_I ;}макрос DEFAULT_I виден всем функциям, чьи определения следуют после определения этого макроса. Если DEFAULT_I определяется в заголовочном файле, то он будет виден в нескольких файлах - даже если он не используется кодом в этих файлах. Та же самая проблема касается также константы, определенной на глобальном уровне.Перечислитель enum особенно полезен в С++, потому что он может быть ограничен областью действия класса и инициализироваться в самом определении класса вместо конструктора. Эти вопросы рассматриваются далее в той главе книги, что посвящена правилам С++.
Наконец, перечислитель может быть использован в качестве аргумента оператора case и размера при объявлении массива. Ни в одной из указанных ситуаций константа использоваться не может.
83. Аргумент параметризированного макроса не должен появляться в правой части более одного раза.
Макрос SQUARE() даже в своем модифицированном виде представил выше серьезную проблему. Дано:
#define SQUARE(x) ((x)*(x))Выражение SQUARE(++x) дважды инкрементирует x. После чего макрос в этом случае дает неверный результат. Если x вначале содержит 2, то SQUARE(++x) вычисляется как 3 * 4. Такое поведение есть пример побочного эффекта макроса - ситуации, когда макрос ведет себя неожиданно.SQUARE(++x) также показывает пример ситуации, в которой использование макроса просто слишком рискованно для оправдания сложностей сопровождения. Встроенная функция С++ или шаблон, расширяемый до встроенной функции, являются более лучшими решениями. Даже в С простую функцию с неудачными аргументами легче сопровождать, чем эквивалентный макрос:
double square( double x ){
return x * x;
}
Но тем не менее, у меня есть серьезное сомнение в том, что использование функции для скрытия простого умножения является стоящим делом.83.1. Никогда не используйте макросы для символьных констант.
Например:
#define SPACE ' 'имеет смысл, если только вы намерены использовать вместо пробела другой символ (как если бы вы испытывали, например, программу для замены символов табуляции).Никогда не делайте так:
#define SPACE 0x20Действительное значение символьной константы для пробела (' ') изменяется компилятором так, чтобы оно соответствовало операционной среде, для которой ведется компиляция. Для среды, поддерживающей ASCII, это значение будет 0x20, а для EBDCDIC - уже нечто другое. Не думайте, что у какого-то символа свое постоянное значение.
84. Если все альтернативы отпали, то используйте препроцессор.
Мы увидим в главе, посвященной С++, что препроцессор С не играет большой роли в С++. Хотя есть немного мест, где он все еще кстати. Вот первое из них:
#ifdef DEBUG# define D(x) x
#else
# define D(X) /* пусто */
#endif
Вместо макроса D() подставляется его аргумент, если вы занимаетесь отладкой, иначе он расширяется до пустой строки. Он используется так: f(){
D( printf("Это отладочная информация\n"); )}В данном случае аргументом D() является целиком оператор printf(), который исчезает после того, как вы закончите отладку.Другой подобный вариант использования кстати, когда вы должны инициализировать те несколько неизбежных глобальных переменных в большой программе. Проблема заключается в синхронизации объявлений переменных (в заголовочном файле) с их определениями (в файле .c), где реально выделяется память и переменные инициализируются. Вот образец заголовочного файла:
#ifdef ALLOC# define I(x) x
# define EXPORTED /* пусто */
#else
# define I(x) /* пусто */
# define EXPORTED extern
#endif
EXPORTED int glob_x[10] I( ={1, 2, 3, 4} );
EXPORTED some_object glob_y I( ("конструктор", "аргументы") );
В определенном месте своей программы (я обычно делаю это в файле с именем globals.cpp) вы помещаете следующие строки: #define ALLOC#include "globals.h"
Далее везде вы просто включаете этот файл без предварительной директивы #define ALLOC. Когда вы компилируете globals.cpp, директива #define ALLOC вызывает следующую подстановку: /* пусто */ int glob_x[10] ={1, 2, 3, 4} ;/* пусто */ some_object glob_y ("конструктор", "аргументы") );
Отсутствие #define ALLOC везде приводит к следующей подстановке: extern int glob_x[10] /* пусто */ ;extern some_object glob_y /* пусто */ ;
Последним примером использования препроцессора будет макрос ASSERT(), который выводит сообщение об ошибке и завершает программу, лишь если вы осуществляете отладку (директивой #define определена константа DEBUG) и аргумент ASSERT() имеет значение "ложь". Он очень удобен для тестирования, например, аргументов типа указателей со значением NULL. Вариант ASSERT(), используемый в виде: f( char *p){
ASSERT( p, "f() : Неожиданный аргумент NULL." );}определяется следующим образом: #ifdef DEBUG#define ASSERT(условие, сообщение)
if ( !(условие) ) \{\
fprintf(stderr, "ASSERT(" #условие ") НЕ ВЫПОЛНЕНО "\ "[Файл " __FILE__ ", Строка %d]:\n\t%s\n",\__LINE__, (сообщение) );\
exit( -1 );\}\else
#else# define ASSERT(c,m) /* пусто */
#endif
В вышеуказанном примере ASSERT() выводит следующую строку при отрицательном результате проверки: ASSERT(p) НЕ ВЫПОЛНЕНО [Файл whatever.cpp, Строка 123]:f() : Неожиданный аргумент NULL.
и затем выходит в вызывающую программу. Он получает текущее имя файла и номер строки от препроцессора, используя предопределенные макросы __FILE__ и __LINE__. Условие, вызывающее отрицательный результат, выводится посредством оператора получения строки ANSI С (символ #), который фактически окружает расширенный аргумент кавычками после выполнения подстановки аргумента. Строка #условие расширяется до "p" в настоящем примере). Затем вступает в действие обычная конкатенация строк С для слияния вместе разных строк, создавая единый отформатированный аргумент для fprintf().Вы должны использовать здесь препроцессор, потому что вам нужно вывести на консоль имя файла и номер строки, для которых выполнена проверка. Встроенная функция С++ может вывести лишь имя того файла с номером строки, в котором определена встроенная функция.
Все компиляторы, поддерживающие стандарт ANSI С, должны реализовывать макрос assert(expr) в заголовочном файле assert.h, но макрос ANSI С не может выводить заказанное сообщение об ошибке. Макрос ANSI С assert() действует, если не определена константа NDEBUG (вариант по умолчанию).