Бьерн Страуструп. Язык программирования С++ --------------------------------------------------------------- Второе дополненное издание --------------------------------------------------------------- Языки программирования / С++ Бьерн Страуструп Язык программирования С++ Книга Б. Страуструпа "Язык программирования С++" дает описание языка, его ключевых понятий и основных приемов программирования на нем. Это завершенное руководство, написанное создателем языка, которое содержит описание всех средств С++, в том числе управление исключитель- ными ситуациями, шаблоны типа (параметризованные типы данных) и мно- жественное наследование. Книга делится на три части. Первые десять глав являются учебником, служащим введением в язык, включая подмножество собственно С. В трех последующих главах обсуждаются вопросы проектирования и создания программного обеспечения с помощью С++. Книга завершается полным справочным руководством по языку. В книге вы найдете: * законченный учебник и руководство по языку. * полное освещение средств языка, нацеленных на абстрактные типы данных и объектно-ориентированное программирование. * обсуждение программистских и технических вопросов, возникающих в про- цессе проектирования и создания больших программных систем. * описание способов построения библиотек высокого класса. * примеры реализации ключевых типов данных, определяемых пользователем, таких как графические объекты, ассоциативные массивы и потоки ввода- вывода. Эта книга будет хорошим помощником опытному программисту, решившему использовать С++ для нетривиальных задач. Ее можно считать ключевой в любом собрании книг по С++. Об авторе книги: Бьерн Страуструп является разработчиком языка С++ и создателем первого транслятора. Он - сотрудник научно-исследовательского вычислительного центра AT&T Bell Laboratories в Мюррей Хилл (Нью-Джерси, США). Он получил звание магистра математики и вычислительной техники в университете г. Аарус (Дания), а докторское звание по вычислительной технике в кэмбриджском университете (Англия). Он специализируется в области рас- пределенных систем, операционных систем, моделирования и программиро- вания. Вместе с М. А. Эллис он является автором полного руководства по языку С++ - "Руководство по С++ с примечаниями". ПРЕДИСЛОВИЕ "А дорога идет все дальше и дальше" (Бильбо Бэгинз) Как было обещано в первом издании книги, запросы пользователей определили развитие С++. Его направлял опыт широкого круга пользователей, работающих в разных областях программирования. За шесть лет, отделяющих нас от первого издания описания С++, число пользователей возросло в сотни раз. За эти годы были усвоены многие уроки, были предложены и подтвердили практикой свое право на существование различные приемы программирования. О некоторых из них и пойдет речь ниже. Сделанные за эти шесть лет расширения языка прежде всего были направлены на повышение выразительности С++ как языка абстракции данных и объектно-ориентированного программирования вообще и как средства для создания высококачественных библиотек с пользовательскими типами данных в частности. Библиотекой высокого качества мы считаем библиотеку, позволяющую пользователю определять с помощью классов понятия, работа с которыми сочетает удобство, эффективность и надежность. Под надежностью понимается то, что класс предоставляет защищенный по типам интерфейс между пользователями библиотеки и ее разработчиками. Эффективность предполагает, что использование классов не влечет за собой больших накладных расходов по памяти или времени по сравнению с "ручными" программами на С. Эта книга является полным описанием языка С++. Главы с 1 по 10 представляют собой учебник, знакомящий с языком. В главах с 11 по 13 обсуждаются вопросы проектирования и развития программного обеспечения. Завершается книга справочным руководством по языку С++. Естественно, что все расширения языка и способы их использования, которые появились после выхода в свет первого издания, являются частью изложения. К ним относятся уточненные правила для разрешения перегрузки имени, средства управления памятью и средства контроля доступа, надежная по типам процедура связывания, статические и постоянные функции-члены, абстрактные классы, множественное наследование, шаблоны типов и обработка особых ситуаций. С++ является языком программирования общего назначения. Естественная для него область применения - системное программирование, понимаемое в широком смысле этого слова. Кроме того, С++ успешно используется во многих областях приложения, далеко выходящих за указанные рамки. Реализации С++ теперь есть на всех машинах, начиная с самых скромных микрокомпьютеров - до самых больших супер-ЭВМ, и практически для всех операционных систем. Поэтому книга дает лишь описание собственно языка, не объясняя особенности конкретных реализаций, среды программирования или библиотек. Читатель найдет в книге много примеров с классами, которые, несмотря на несомненную пользу, можно считать игрушечными. Такой стиль изложения позволяет лучше выделить основные понятия и полезные приемы, тогда как в настоящих, законченных программах они были бы скрыты массой деталей. Для большинства предложенных здесь классов, как то связанные списки, массивы, строки символов, матрицы, графические классы, ассоциативные массивы и т.д., - приводятся версии "со 100% гарантией" надежности и правильности, полученные на основе классов из самых разных коммерческих и некоммерческих программ. Многие из "промышленных" классов и библиотек получились как прямые или косвенные потомки игрушечных классов, приводимых здесь как примеры. В этом издании книги по сравнению с первым больше внимания уделено задаче обучения. Вместе с тем, уровень изложения в равной мере учитывает и опытных программистов, ни в чем не умаляя их знаний и профессионализма. Обсуждение вопросов проектирования сопровождается более широкой подачей материала, выходящей за рамки описаний конструкций языка и способам их использования. В этом издании приводится больше технических деталей и повышена строгость изложения. В особенности это относится к справочному руководству, которое вобрало в себя многолетний опыт работы в этом направлении. Предполагалось создать книгу с достаточно высоким уровнем изложения, которая бы служила программистам не только книгой для чтения. Итак, перед вами книга с описанием языка С++, его основных принципов и методов программирования. Надеемся, что она доставит вам радость. Выражение признательности Кроме лиц, перечисленных в соответствующем разделе предисловия к первому изданию книги, мне хотелось бы выразить свою благодарность Элу Эхо, Стиву Бароффу, Джиму Коплину, Тому Хансену, Петеру Джаглу, Брайану Кернигану, Эндрю Кенигу, Биллу Леггету, Лоррейн Мингаччи, Уоррену Монтгомери, Майку Моубри, Робу Мюррею, Джонатану Шапиро, Майку Вилоту и Петеру Вейнбергу за комментарии черновых вариантов второго издания книги. В развитии языка С++ за период от 1985 до 1991 гг. принимали участие многие специалисты. Я могу упомянуть лишь нескольких из них: Эндрю Кенига, Брайана Кернигана, Дага Макилроя и Джонатана Шапиро. Кроме того, выражаю признательность многим участникам создания справочного руководства С++, предложившим свои варианты, а также тем, с кем довелось нести тяжкую ношу в течение первого года работы комитета X3J16 по стандартизации языка С++. Мюррей-Хилл, шт.Нью Джерси Бьерн Страуструп ПРЕДИСЛОВИЕ К ПЕРВОМУ ИЗДАНИЮ "Язык образует среду мышления и формирует представление о том, о чем мы думаем". (Б.Л.Уорф) С++ - язык общего назначения и задуман для того, чтобы настоящие программисты получили удовольствие от самого процесса программирования. За исключением второстепенных деталей он содержит язык С как подмножество. Язык С расширяется введением гибких и эффективных средств, предназначенных для построения новых типов. Программист структурирует свою задачу, определив новые типы, которые точно соответствуют понятиям предметной области задачи. Такой метод построения программы обычно называют абстракцией данных. Информация о типах содержится в некоторых объектах типов, определенных пользователем. С такими объектами можно работать надежно и просто даже в тех случаях, когда их тип нельзя установить на стадии трансляции. Программирование с использованием таких объектов обычно называют объектно-ориентированным. Если этот метод применяется правильно, то программы становятся короче и понятнее, а сопровождение их упрощается. Ключевым понятием С++ является класс. Класс - это определяемый пользователем тип. Классы обеспечивают упрятывание данных, их инициализацию, неявное преобразование пользовательских типов, динамическое задание типов, контролируемое пользователем управление памятью и средства для перегрузки операций. В языке С++ концепции контроля типов и модульного построения программ реализованы более полно, чем в С. Кроме того, С++ содержит усовершенствования, прямо с классами не связанные: символические константы, функции-подстановки, стандартные значения параметров функций, перегрузка имен функций, операции управления свободной памятью и ссылочный тип. В С++ сохранены все возможности С эффективной работы с основными объектами, отражающими аппаратную "реальность" (разряды, байты, слова, адреса и т.д.). Это позволяет достаточно эффективно реализовывать пользовательские типы. Как язык, так и стандартные библиотеки С++ проектировались в расчете на переносимость. Имеющиеся реализации языка будут работать в большинстве систем, поддерживающих С. В программах на С++ можно использовать библиотеки С. Большинство служебных программ, рассчитанных на С, можно использовать и в С++. Данная книга в первую очередь рассчитана на профессиональных программистов, желающих изучить новый язык и использовать его для нетривиальных задач. В книге дается полное описание С++, содержится много завершенных примеров и еще больше фрагментов программ. Выражение признательности Язык С++ никогда бы не стал реальностью без, если бы постоянно не использовались предложения и советы и не учитывалась конструктивная критика со стороны многих друзей и коллег. Особенно следует упомянуть Тома Карджила, Джима Копли, Стью Фельдмана, Сэнди Фрэзера, Стива Джонсона, Брайана Кернигана, Барта Локанти, Дага Макилроя, Дэнниса Ритчи, Лэрри Рослера, Джерри Шварца и Джона Шапиро, которые внесли важные для развития языка идеи. Дэйв Пресотто реализовал текущую версию библиотеки потокового ввода/вывода. Свой вклад в развитие С++ и создание транслятора внесли сотни людей, которые присылали мне предложения по совершенствованию языка, описания трудностей, с которыми они сталкивались, и ошибки транслятора. Здесь я могу упомянуть лишь некоторых из них: Гари Бишопа, Эндрю Хьюма, Тома Карцеса, Виктора Миленковича, Роба Мюррэя, Леони Росс, Брайана Шмальта и Гарри Уокера. Многие участвовали в подготовке книги к изданию, особенно Джон Бентли, Лаура Ивс, Брайан Керниган, Тэд Ковальски, Стив Махани, Джон Шапиро и участники семинара по языку С++, который проводился фирмой Bell Labs в Колумбии, Огайо, 26-27 июня 1985 г. Мюррей-Хилл, шт.Нью-Джерси Бьерн Страуструп ПРЕДВАРИТЕЛЬНЫЕ ЗАМЕЧАНИЯ "О многом - молвил Морж,- пришла пора поговорить ". Л.Кэрролл Данная глава содержит краткий обзор книги, список литературы и некоторые дополнительные замечания о языке С++. Замечания касаются истории создания С++, идей, которые оказали существенное влияние на разработку языка, и некоторых мыслей по поводу программирования на С++. Эта глава не является введением; приведенные замечания не являются необходимыми для понимания последующих глав. Некоторые из них предполагают знакомство читателя с С++. Структура книги Книга состоит из трех частей. Главы с 1 по 10 являются учебником по языку. В главах с 11 по 13 обсуждаются вопросы проектирования и развития программного обеспечения с учетом возможностей С++. В конце книги приведено полное справочное руководство по языку. Исчерпывающее описание конструкций С++ содержится только там. Учебная часть книги содержит примеры, советы, предостережения и упражнения, для которых не нашлось места в руководстве. Книга в основном посвящена вопросу, как с помощью языка C++ структурировать программу, а не вопросу, как записать на нем алгоритм. Следовательно, там, где можно было выбирать, предпочтение отдавалось не профессиональным, но сложным для понимания, а тривиальным алгоритмам. Так в одном из примеров используется пузырьковая сортировка, хотя алгоритм быстрой сортировки больше подходит для настоящей программы. Часто написать ту же программу, но с более эффективным алгоритмом, предлагается в виде упражнения. Глава 1 содержит краткий обзор основных концепций и конструкций С++. Она позволяет познакомиться с языком в общих чертах. Подробные объяснения конструкций языка и способов их применения содержатся в последующих главах. Обсуждаются в первую очередь средства, обеспечивающие абстракцию данных и объектно-ориентированное программирование. Основные средства процедурного программирования упоминаются кратко. В главах 2, 3 и 4 описываются средства С++, которые не используются для определения новых типов: основные типы, выражения и структуры управления. Другими словами, эти главы содержат описание той части языка, которая по сути представляет С. Изложение в указанных главах идет в углубленном виде. Главы 5 - 8 посвящены средствам построения новых типов, которые не имеют аналогов в С. В главе 5 вводится основное понятие - класс. В ней показано, как можно определять пользовательские типы (классы), инициализировать их, обращаться к ним, и, наконец, как уничтожать их. Глава 6 посвящена понятию производных классов, которое позволяет строить из простых классов более сложные. Оно дает также возможность эффективной и безопасной (в смысле типа) работы в тех ситуациях, когда типы объектов на стадии трансляции неизвестны. В главе 7 объясняется, как можно определить унарные и бинарные операции для пользовательских типов, как задавать преобразования таких типов, и каким образом можно создавать, копировать и удалять объекты, представляющие пользовательские типы. Глава 8 посвящена шаблонам типа, т.е. такому средству С++, которое позволяет определить семейство типов и функций. В главе 9 обсуждается обработка особых ситуаций, рассматриваются возможные реакции на ошибки и методы построения устойчивых к ошибкам систем. В главе 10 определяются классы ostream и istream, предоставляемые стандартной библиотекой для потокового ввода-вывода. Главы 11 - 13 посвящены вопросам, связанным с применением С++ для проектирования и реализации больших программных систем. В главе 11 в основном рассматриваются вопросы проектирования и управления программными проектами. В главе 12 обсуждается взаимосвязь между языком С++ и проблемами проектирования. В главе 13 показаны способы создания библиотек. Завершается книга справочным руководством по С++. Ссылки на различные части книги даются в виде $$2.3.4, что означает раздел 3.4 главы 2. Для обозначения справочного руководства применяется буква R, например, $$R.8.5.5. Замечания по реализации Существует несколько распространяемых независимых реализаций С++. Появилось большое число сервисных программ, библиотек и интегрированных систем программирования. Имеется масса книг, руководств, журналов, статей, сообщений по электронной почте, технических бюллетеней, отчетов о конференциях и курсов, из которых можно получить все необходимые сведения о последних изменениях в С++, его использовании, сервисных программах, библиотеках, новых трансляторах и т.д. Если вы серьезно рассчитываете на С++, стоит получить доступ хотя бы к двум источникам информации, поскольку у каждого источника может быть своя позиция. Большинство программных фрагментов, приведенных в книге, взяты непосредственно из текстов программ, которые были транслированы на машине DEC VAX 11/8550 под управлением 10-й версии системы UNIX [25]. Использовался транслятор, являющийся прямым потомком транслятора С++, созданного автором. Здесь описывается "чистый С++", т.е. не используются никакие зависящие от реализации расширения. Следовательно, примеры должны идти при любой реализации языка. Однако, шаблоны типа и обработка особых ситуаций относятся к самым последним расширениям языка, и возможно, что ваш транслятор их не содержит. Упражнения Упражнения даются в конце каждой главы. Чаще всего они предлагают написать программу. Решением может считаться программа, которая транслируется и правильно работает хотя бы на нескольких тестах. Упражнения могут значительно различаться по сложности, поэтому дается приблизительная оценка степени их сложности. Рост сложности экспоненциальный, так что, если на упражнение (*1) у вас уйдет пять минут, то (*2) может занять час, а (*3) - целый день. Однако время написания и отладки программы больше зависит от опыта читателя, чем от самого упражнения. На упражнение (*1) может потребоваться целый день, если перед запуском программы читателю придется ознакомиться с новой вычислительной системой. С другой стороны, тот, у кого под рукой окажется нужный набор программ, может сделать упражнение (*5) за один час. Любую книгу по программированию на языке С можно использовать как источник дополнительных упражнений при изучении глав 2 - 4. В книге Ахо ([1]) приведено много общих структур данных и алгоритмов в терминах абстрактных типов данных. Эту книгу также можно использовать как источник упражнений при изучении глав 5 - 8. Однако, использованному в ней языку не достает функций-членов и производных классов. Поэтому определяемые пользователем типы на С++ можно написать более элегантно. Замечания по проекту языка При разработке языка С++ одним из важнейших критериев выбора была простота. Когда возникал вопрос, что упростить: руководство по языку и другую документацию или транслятор, - то выбор делали в пользу первого. Огромное значение придавалось совместимости с языком С, что помешало удалить его синтаксис. В С++ нет типов данных и элементарных операций высокого уровня. Например, не существует типа матрица с операцией обращения или типа строка с операцией конкатенации. Если пользователю понадобятся подобные типы, он может определить их в самом языке. Программирование на С++ по сути сводится к определению универсальных или зависящих от области приложения типов. Хорошо продуманный пользовательский тип отличается от встроенного типа только способом определения, но не способом применения. Из языка исключались возможности, которые могут привести к накладным расходам памяти или времени выполнения, даже если они непосредственно не используются в программе. Например, было отвергнуто предложение хранить в каждом объекте некоторую служебную информацию. Если пользователь описал структуру, содержащую две величины, занимающие по 16 разрядов, то гарантируется, что она поместится в 32-х разрядный регистр. Язык С++ проектировался для использования в довольно традиционной среде, а именно: в системе программирования С операционной системы UNIX. Но есть вполне обоснованные доводы в пользу использования С++ в более богатой программной среде. Такие возможности, как динамическая загрузка, развитые системы трансляции и базы данных для хранения определений типов, можно успешно использовать без ущерба для языка. Типы С++ и механизмы упрятывания данных рассчитаны на определенный синтаксический анализ, проводимый транслятором для обнаружения случайной порчи данных. Они не обеспечивают секретности данных и защиты от умышленного нарушения правил доступа к ним. Однако, эти средства можно свободно использовать, не боясь накладных расходов памяти и времени выполнения программы. Учтено, что конструкция языка активно используется тогда, когда она не только изящно записывается на нем, но и вполне по средствам обычным программам. Историческая справка Безусловно С++ многим обязан языку С [8], который сохраняется как его подмножество. Сохранены и все свойственные С средства низкого уровня, предназначенные для решения самых насущных задач системного программирования. С, в свою очередь, многим обязан своему предшественнику языку BCPL [13]. Комментарий языка BCPL был восстановлен в С++. Если читатель знаком с языком BCPL, то может заметить, что в С++ по-прежнему нет блока VALOF. Еще одним источником вдохновения был язык SIMULA-67 [2,3]; именно из него была заимствована концепция классов (вместе c производными классами и виртуальными функциями). Оператор inspect из SIMULA-67 намеренно не был включен в С++. Причина - желание способствовать модульности за счет использования виртуальных функций. Возможность в С++ перегрузки операций и свобода размещения описаний всюду, где может встречаться оператор, напоминают язык Алгол-68 [24]. С момента выхода в свет первого издания этой книги язык С++ подвергся существенным изменениям и уточнениям. В основном это касается разрешения неоднозначности при перегрузке, связывании и управлении памятью. Вместе с тем, были внесены незначительные изменения с целью увеличить совместимость с языком С. Были также введены некоторые обобщения и существенные расширения, как то: множественное наследование, функции-члены со спецификациями static и const, защищенные члены (protected), шаблоны типа и обработка особых ситуаций. Все эти расширения и доработки были нацелены на то, чтобы С++ стал языком, на котором можно создавать и использовать библиотеки. Все изменения описываются в [10,18,20,21 и 23]. Шаблоны типов появились частично из-за желания формализовать макросредства, а частично были инспирированы описанием генерических объектов в языке Ада (с учетом их достоинств и недостатков) и параметризированными модулями языка CLU. Механизм обработки особых ситуаций появился отчасти под влиянием языков Ада и CLU [11], а отчасти под влиянием ML [26]. Другие расширения, введенные за период между 1985 и 1991 г.г. (такие как множественное наследование, статические функции-члены и чистые виртуальные функции), скорее появились в результате обобщения опыта программирования на С++, чем были почерпнуты из других языков. Более ранние версии языка, получившие название "С с классами" [16], использовались, начиная с 1980 г. Этот язык возник потому, что автору потребовалось написать программы моделирования, управляемые прерываниями. Язык SIMULA-67 идеально подходит для этого, если не учитывать эффективность. Язык "С с классами" использовался для больших задач моделирования. Строгой проверке подверглись тогда возможности написания на нем программ, для которых критичны ресурсы времени и памяти. В этом языке недоставало перегрузки операций, ссылок, виртуальных функций и многих других возможностей. Впервые С++ вышел за пределы исследовательской группы, в которой работал автор, в июле 1983 г., однако тогда многие возможности С++ еще не были разработаны. Название С++ (си плюс плюс) , было придумано Риком Маскитти летом 1983 г. Это название отражает эволюционный характер изменений языка С. Обозначение ++ относится к операции наращивания С. Чуть более короткое имя С+ является синтаксической ошибкой. Кроме того, оно уже было использовано как название совсем другого языка. Знатоки семантики С находят, что С++ хуже, чем ++С. Язык не получил названия D, поскольку он является расширением С, и в нем не делается попыток решить какие-либо проблемы за счет отказа от возможностей С. Еще одну интересную интерпретацию названия С++ можно найти в приложении к [12]. Изначально С++ был задуман для того, чтобы автору и его друзьям не надо было программировать на ассемблере, С или других современных языках высокого уровня. Основное его предназначение - упростить и сделать более приятным процесс программирования для отдельного программиста. До недавнего времени не было плана разработки С++ на бумаге. Проектирование, реализация и документирование шли параллельно. Никогда не существовало "проекта С++" или "Комитета по разработке С++". Поэтому язык развивался и продолжает развиваться так, чтобы преодолеть все проблемы, с которыми столкнулись пользователи. Толчками к развитию служат также и обсуждения автором всех проблем с его друзьями и коллегами. В связи с лавинообразным процессом увеличения числа пользователей С++, пришлось сделать следующие изменения. Примерно в 1987 г. стало очевидно, что работа по стандартизации С++ неизбежна и что следует незамедлительно приступить к созданию основы для нее [22]. В результате были предприняты целенаправленные действия, чтобы установить контакт между разработчиками С++ и большинством пользователей. Применялась обычная и электронная почта, а также было непосредственное общение на конференциях по С++ и других встречах. Фирма AT&T Bell Laboratories внесла основной вклад в эту работу, предоставив автору право изучать версии справочного руководства по языку вместе с упоминавшимися разработчиками и пользователями. Не следует недооценивать этот вклад, т.к. многие из них работают в компаниях, которые можно считать конкурентами фирмы AT&T. Менее просвещенная компания могла бы просто ничего не делать, и в результате появилось бы несколько несогласованных версий языка. Около ста представителей из порядка 20 организаций изучали и комментировали то, что стало современной версией справочного руководства и исходными материалами для ANSI по стандартизации С++. Их имена можно найти в "Аннотированном справочном руководстве по языку С++" [4]. Справочное руководство полностью вошло в настоящую книгу. Наконец, по инициативе фирмы Hewlett-Packard в декабре 1989 г. в составе ANSI был образован комитет X3J16. Ожидается, что работы по стандартизации С++ в ANSI (американский стандарт) станут составной частью работ по стандартизации силами ISO (Международной организации по стандартизации). С++ развивался одновременно с развитием некоторых фундаментальных классов, представленных в данной книге. Например, автор разрабатывал классы complex, vector и stack, создавая одновременно возможность перегрузки операций. В результате этих же усилий и благодаря содействию Д. Шапиро появились строковые и списочные классы. Эти классы стали первыми библиотечными классами, которые начали активно использоваться. Библиотека task, описываемая в [19] и в упражнении 13 из $$6.8 стала частью самой первой программы, написанной на языке "С с классами". Эта программа и используемые в ней классы были созданы для моделирования в стиле Симулы. Библиотека task была существенно переработана Д. Шапиро и продолжает активно использоваться до настоящего времени. Потоковая библиотека, как указывалось в первом издании книги, была разработана и применена автором. Д. Шварц преобразовал ее в потоковую библиотеку ввода-вывода ($$10), используя наряду с другими приемами метод манипуляторов Э.Кенига ($$10.4.2). Класс map ($$8.8) был предложен Э.Кенигом. Он же создал класс Pool ($$13.10), чтобы использовать для библиотеки предложенный автором способ распределения памяти для классов ($$5.5.6). На создание остальных шаблонов повлияли шаблоны Vector, Map, Slist и sort, представленные в главе 8. Сравнение языков С++ и С Выбор С в качестве базового языка для С++ объясняется следующими его достоинствами: (1) универсальность, краткость и относительно низкий уровень; (2) адекватность большинству задач системного программирования; (3) он идет в любой системе и на любой машине; (4) полностью подходит для программной среды UNIX. В С существуют свои проблемы, но в языке, разрабатываемом "с нуля" они появились бы тоже, а проблемы С, по крайней мере, хорошо известны. Более важно то, что ориентация на С позволила использовать язык "С с классами" как полезный (хотя и не очень удобный) инструмент в течение первых месяцев раздумий о введении в С классов в стиле Симулы. С++ стал использоваться шире, но по мере роста его возможностей, выходящих за пределы С, вновь и вновь возникала проблема совместимости. Ясно, что отказавшись от части наследства С, можно избежать некоторых проблем (см., например, [15]). Это не было сделано по следующим причинам: (1) существуют миллионы строк программ на С, которые можно улучшить с помощью С++, но при условии, что полной переписи их на язык С++ не потребуется; (2) существуют миллионы строк библиотечных функций и служебных программ на С, которые можно было бы использовать в С++ при условиях совместимости обоих языков на стадии связывания и их большого синтаксического сходства; (3) существуют сотни тысяч программистов, знающих С; им достаточно овладеть только новыми средствами С++ и не надо изучать основ языка; (4) поскольку С и С++ будут использоваться одними и теми же людьми на одних и тех же системах многие годы, различия между языками должны быть либо минимальными, либо максимальными, чтобы свести к минимуму количество ошибок и недоразумений. Описание С++ было переработано так, чтобы гарантировать, что любая допустимая в обоих языках конструкция означала в них одно и то же. Язык С сам развивался в последние несколько лет, что отчасти было связано с разработкой С++ [14]. Стандарт ANSI для С [27] содержит, например, синтаксис описания функций, позаимствованный из языка "С с классами". Происходит взаимное заимствование, например, тип указателя void* был придуман для ANSI С, а впервые реализован в С++. Как было обещано в первом издании этой книги, описание С++ было доработано, чтобы исключить неоправданные расхождения. Теперь С++ более совместим с языком С, чем это было вначале ($$R.18). В идеале С++ должен максимально приближаться к ANSI C, но не более [9]. Стопроцентной совместимости никогда не было и не будет, поскольку это нарушит надежность типов и согласованность использования встроенных и пользовательских типов, а эти свойства всегда были одними из главных для С++. Для изучения С++ не обязательно знать С. Программирование на С способствует усвоению приемов и даже трюков, которые при программировании на С++ становятся просто ненужными. Например, явное преобразование типа (приведение) , в С++ нужно гораздо реже, чем в С (см. "Замечания для программистов на С" ниже). Тем не менее, хорошие программы на языке С по сути являются программами на С++. Например, все программы из классического описания С [8] являются программами на С++. В процессе изучения С++ будет полезен опыт работы с любым языком со статическими типами. Эффективность и структура Развитие языка С++ происходило на базе языка С, и, за небольшим исключением, С был сохранен в качестве подмножества C++. Базовый язык С был спроектирован таким образом, что имеется очень тесная связь между типами, операциями, операторами и объектами, с которыми непосредственно работает машина, т.е. числами, символами и адресами. За исключением операций new, delete и throw, а также проверяемого блока, для выполнения операторов и выражений С++ не требуется скрытой динамической аппаратной или программной поддержки. В С++ используется та же (или даже более эффективная) последовательность команд для вызова функций и возврата из них, что и в С. Если даже эти довольно эффективные операции становятся слишком дорогими, то вызов функции может быть заменен подстановкой ее тела, причем сохраняется удобная функциональная запись безо всяких расходов на вызов функции. Первоначально язык С задумывался как конкурент ассемблера, способный вытеснить его из основных и наиболее требовательных к ресурсам задач системного программирования. В проекте С++ были приняты меры, чтобы успехи С в этой области не оказались под угрозой. Различие между двумя языками прежде все состоит в степени внимания, уделяемого типам и структурам. Язык С выразителен и в то же время снисходителен по отношению к типам. Язык С++ еще более выразителен, но такой выразительности можно достичь лишь тогда, когда типам уделяют большое внимание. Когда типы объектов известны, транслятор правильно распознает такие выражения, в которых иначе программисту пришлось бы записывать операции с утомительными подробностями. Кроме того, знание типов позволяет транслятору обнаруживать такие ошибки, которые в противном случае были бы выявлены только при тестировании. Отметим, что само по себе использование строгой типизации языка для контроля параметров функции, защиты данных от незаконного доступа, определения новых типов и операций не влечет дополнительных расходов памяти и увеличения времени выполнения программы. В проекте С++ особое внимание уделяется структурированию программы. Это вызвано увеличением размеров программ со времени появления С. Небольшую программу (скажем, не более 1000 строк) можно заставить из упрямства работать, нарушая все правила хорошего стиля программирования. Однако, действуя так, человек уже не сможет справиться с большой программой. Если у вашей программы в 10 000 строк плохая структура, то вы обнаружите, что новые ошибки появляются в ней так же быстро, как удаляются старые. С++ создавался с целью, чтобы большую программу можно было структурировать таким образом, чтобы одному человеку не пришлось работать с текстом в 25000 строк. В настоящее время можно считать, что эта цель полностью достигнута. Существуют, конечно, программы еще большего размера. Однако те из них, которые действительно используются, обычно можно разбить на несколько практически независимых частей, каждая из которых имеет значительно меньший упомянутого размер. Естественно, трудность написания и сопровождения программы определяется не только числом строк текста, но и сложностью предметной области. Так что приведенные здесь числа, которыми обосновывались наши соображения, не надо воспринимать слишком серьезно. К сожалению, не всякую часть программы можно хорошо структурировать, сделать независимой от аппаратуры, достаточно понятной и т.д. В С++ есть средства, непосредственно и эффективно представляющие аппаратные возможности. Их использование позволяет избавиться от беспокойства о надежности и простоте понимания программы. Такие части программы можно скрывать, предоставляя надежный и простой интерфейс с ними. Естественно, если С++ используется для большой программы, то это означает, что язык используют группы программистов. Полезную роль здесь сыграют свойственные языку модульность, гибкость и строго типизированные интерфейсы. В С++ есть такой же хороший набор средств для создания больших программ, как во многих языках. Но когда программа становится еще больше, проблемы по ее созданию и сопровождению перемещаются из области языка в более глобальную область программных средств и управления проектом. Этим вопросам посвящены главы 11 и 12. В этой книге основное внимание уделяется методам создания универсальных средств, полезных типов, библиотек и т.д. Эти методы можно успешно применять как для маленьких, так и для больших программ. Более того, поскольку все нетривиальные программы состоят из нескольких в значительной степени независимых друг от друга частей, методы программирования отдельных частей пригодятся как системным, так и прикладным программистам. Может возникнуть подозрение, что запись программы с использованием подробной системы типов, увеличит размер текста. Для программы на С++ это не так: программа на С++, в которой описаны типы формальных параметров функций, определены классы и т.п., обычно бывает даже короче своего эквивалента на С, где эти средства не используются. Когда в программе на С++ используются библиотеки, она также оказывается короче своего эквивалента на С, если, конечно, он существует. Философские замечания Язык программирования решает две взаимосвязанные задачи: позволяет программисту записать подлежащие выполнению действия и формирует понятия, которыми программист оперирует, размышляя о своей задаче. Первой цели идеально отвечает язык, который очень "близок машине". Тогда со всеми ее основными "сущностями" можно просто и эффективно работать на этом языке, причем делая это очевидным для программиста способом. Именно это имели в виду создатели С. Второй цели идеально отвечает язык, который настолько "близок к поставленной задаче", что на нем непосредственно и точно выражаются понятия, используемые в решении задачи. Именно это имелось в виду, когда первоначально определялись средства, добавляемые к С. Связь между языком, на котором мы думаем и программируем, а также между задачами и их решениями, которые можно представить в своем воображении, довольно близка. По этой причине ограничивать возможности языка только поиском ошибок программиста - в лучшем случае опасно. Как и в случае естественных языков, очень полезно обладать, по крайней мере, двуязычием. Язык предоставляет программисту некоторые понятия в виде языковых инструментов; если они не подходят для задачи, их просто игнорируют. Например, если существенно ограничить понятие указателя, то программист будет вынужден для создания структур, указателей и т.п. использовать вектора и операции с целыми. Хороший проект программы и отсутствие в ней ошибок нельзя гарантировать только наличием или отсутствием определенных возможностей в языке. Типизация языка должна быть особенно полезна для нетривиальных задач. Действительно, понятие класса в С++ проявило себя как мощное концептуальное средство. Замечания о программировании на языке С++ Предполагается, что в идеальном случае разработка программы делится на три этапа: вначале необходимо добиться ясного понимания задачи, затем определить ключевые понятия, используемые для ее решения, и, наконец, полученное решение выразить в виде программы. Однако, детали решения и точные понятия, которые будут использоваться в нем, часто проясняются только после того, как их попытаются выразить в программе. Именно в этом случае большое значение приобретает выбор языка программирования. Во многих задачах используются понятия, которые трудно представить в программе в виде одного из основных типов или в виде функции без связанных с ней статических данных. Такое понятие может представлять в программе класс. Класс - это тип; он определяет поведение связанных с ним объектов: их создание, обработку и уничтожение. Кроме этого, класс определяет реализацию объектов в языке, но на начальных стадиях разработки программы это не является и не должно являться главной заботой. Для написания хорошей программы надо составить такой набор классов, в котором каждый класс четко представляет одно понятие. Обычно это означает, что программист должен сосредоточиться на вопросах: Как создаются объекты данного класса? Могут ли они копироваться и (или) уничтожаться? Какие операции можно определить над этими объектами? Если на эти вопросы удовлетворительных ответов не находится, то, скорее всего, это означает, что понятие не было достаточно ясно сформулировано. Тогда, возможно, стоит еще поразмышлять над задачей и предлагаемым решением, а не немедленно приступать к программированию, надеясь в процессе него найти ответы. Проще всего работать с понятиями, которые имеют традиционную математическую форму представления: всевозможные числа, множества, геометрические фигуры и т.д. Для таких понятий полезно было бы иметь стандартные библиотеки классов, но к моменту написания книги их еще не было. В программном мире накоплено удивительное богатство из таких библиотек, но нет ни формального, ни фактического стандарта на них. Язык С++ еще достаточно молод, и его библиотеки не развились в такой степени, как сам язык. Понятие не существует в вакууме, вокруг него всегда группируются связанные с ним понятия. Определить в программе взаимоотношения классов, иными словами, установить точные связи между используемыми в задаче понятиями, бывает труднее, чем определить каждый из классов сам по себе. В результате не должно получиться "каши" - когда каждый класс (понятие) зависит от всех остальных. Пусть есть два класса A и B. Тогда связи между ними типа "A вызывает функцию из B", "A создает объекты B", "A имеет член типа B" обычно не вызывают каких-либо трудностей. Связи же типа "A использует данные из B", как правило, можно вообще исключить. Одно из самых мощных интеллектуальных средств, позволяющих справиться со сложностью, - это иерархическое упорядочение, т.е. упорядочение связанных между собой понятий в древовидную структуру, в которой самое общее понятие находится в корне дерева. Часто удается организовать классы программы как множество деревьев или как направленный ацикличный граф. Это означает, что программист определяет набор базовых классов, каждый из которых имеет свое множество производных классов. Набор операций самого общего вида для базовых классов (понятий) обычно определяется с помощью виртуальных функций ($$6.5). Интерпретация этих операций, по мере надобности, может уточняться для каждого конкретного случая, т.е. для каждого производного класса. Естественно, есть ограничения и при такой организации программы. Иногда используемые в программе понятия не удается упорядочить даже с помощью направленного ацикличного графа. Некоторые понятия оказываются по своей природе взаимосвязанными. Циклические зависимости не вызовут проблем, если множество взаимосвязанных классов настолько мало, что в нем легко разобраться. Для представления на С++ множества взаимозависимых классов можно использовать дружественные классы ($$5.4.1). Если понятия программы нельзя упорядочить в виде дерева или направленного ацикличного графа, а множество взаимозависимых понятий не поддается локализации, то, по всей видимости, вы попали в такое затруднительное положение, выйти из которого не сможет помочь ни один из языков программирования. Если вам не удалось достаточно просто сформулировать связи между основными понятиями задачи, то, скорее всего, вам не удастся ее запрограммировать. Еще один способ выражения общности понятий в языке предоставляют шаблоны типа. Шаблонный класс задает целое семейство классов. Например, шаблонный класс список задает классы вида "список объектов T", где T может быть произвольным типом. Таким образом, шаблонный тип указывает, как получается новый тип из заданного в качестве параметра. Самые типичные шаблонные классы - это контейнеры, в частности, списки, массивы и ассоциативные массивы. Напомним, что можно легко и просто запрограммировать многие задачи, используя только простые типы, структуры данных, обычные функции и несколько классов из стандартных библиотек. Весь аппарат построения новых типов следует привлекать только тогда, когда он действительно необходим. Вопрос "Как написать хорошую программу на С++?" очень похож на вопрос "Как пишется хорошая английская проза?". На него есть два ответа: "Нужно знать, что вы, собственно, хотите написать" и "Практика и подражание хорошему стилю". Оба совета пригодны для С++ в той же мере, что и для английского языка, и обоим достаточно трудно следовать. Несколько полезных советов Ниже представлен "свод правил", который стоит учитывать при изучении С++. Когда вы станете более опытными, то на базе этих правил сможете сформулировать свои собственные, которые будут более подходить для ваших задач и более соответствовать вашему стилю программирования. Сознательно выбраны очень простые правила, и в них опущены подробности. Не следует воспринимать их слишком буквально. Хорошая программа требует и ума, и вкуса, и терпения. С первого раза обычно она не получается, поэтому экспериментируйте! Итак, свод правил. [1] Когда вы пишите программу, то создаете конкретные представления тех понятий, которые использовались в решении поставленной задачи. Структура программы должна отражать эти понятия настолько явно, насколько это возможно. [a] Если вы считаете "нечто" отдельным понятием, то сделайте его классом. [b] Если вы считаете "нечто" существующим независимо, то сделайте его объектом некоторого класса. [c] Если два класса имеют нечто существенное, и оно является для них общим, то выразите эту общность с помощью базового класса. [d] Если класс является контейнером некоторых объектов, сделайте его шаблонным классом. [2] Если определяется класс, который не реализует математических объектов вроде матриц или комплексных чисел и не является типом низкого уровня наподобие связанного списка, то: [а] Не используйте глобальных данных. [b] Не используйте глобальных функций (не членов). [c] Не используйте общих данных-членов. [d] Не используйте функции friend (но только для того, чтобы избежать [а], [b] или [c]). [e] Не обращайтесь к данным-членам другого объекта непосредственно. [f] Не заводите в классе "поле типа"; используйте виртуальные функции. [g] Используйте функции-подстановки только как средство значительной оптимизации. Замечание для программистов на С Чем лучше программист знает С, тем труднее будет для него при программировании на С++ отойти от стиля программирования на С. Так он теряет потенциальные преимущества С++. Поэтому советуем просмотреть раздел "Отличия от С" в справочном руководстве ($$R.18). Здесь мы только укажем на те места, в которых использование дополнительных возможностей С++ приводит к лучшему решению, чем программирование на чистом С. Макрокоманды практически не нужны в С++: используйте const ($$2.5) или enum ($$2.5.1), чтобы определить поименованные константы; используйте inline ($$4.6.2), чтобы избежать расходов ресурсов, связанных с вызовом функций; используйте шаблоны типа ($$8), чтобы задать семейство функций и типов. Не описывайте переменную, пока она действительно вам не понадобится, а тогда ее можно сразу инициализировать, ведь в С++ описание может появляться в любом месте, где допустим оператор. Не используйте malloc(), эту операцию лучше реализует new ($$3.2.6). Объединения нужны не столь часто, как в С, поскольку альтернативность в структурах реализуется с помощью производных классов. Старайтесь обойтись без объединений, но если они все-таки нужны, не включайте их в основные интерфейсы; используйте безымянные объединения ($$2.6.2). Старайтесь не использовать указателей типа void*, арифметических операций с указателями, массивов в стиле С и операций приведения. Если все-таки вы используете эти конструкции, упрятывайте их достаточно надежно в какую-нибудь функцию или класс. Укажем, что связывание в стиле С возможно для функции на С++, если она описана со спецификацией extern "C" ($$4.4). Но гораздо важнее стараться думать о программе как о множестве взаимосвязанных понятий, представляемых классами и объектами, чем представлять ее как сумму структур данных и функций, что-то делающих с этими данными. Список литературы В книге немного непосредственных ссылок на литературу. Здесь приведен список книг и статей, на которые есть прямые ссылки, а также тех, которые только упоминаются. [1] A.V.Aho, J.E.Hopcroft, and J.D.Ulman: Data Structures and Algoritms. Addison-Wesley, Reading, Massachusetts. 1983. [2] O-J.Dahl, B.Myrhaug, and K.Nugaard: SIMULA Common Base Language. Norwegian Computing Ctnter S-22. Oslo, Norway. 1970 [3] O-J.Dahl and C.A.R.Hoare: Hierarhical Program Construction in Structured Programming. Academic Press, New York. 1972. pp. 174-220. [4] Margaret A.Ellis and Bjarne Stroustrup: The Annotated C++ Reference Manual. Addison-Wesley, Reading, Massachusetts. 1990. [5] A.Goldberg and D.Rodson: SMALLTALK-80 - The Language and Its Implementation. Addison-Wesley, Reading, Massachusetts. 1983. [6] R.E.Griswold et.al.: The Snobol14 Programming Language. Prentice-Hall, Englewood Cliffs, New Jersy, 1970. [7] R.E.Griswold and M.T.Griswold: The ICON Programming Language. Prentice-Hall, Englewood Cliffs, New Jersy. 1983. [8] Brian W.Kernighan and Dennis M.Ritchie: The C Programming Language. Prentice-Hall, Englewood Cliffs, New Jersy. 1978. Second edition 1988. [9] Andrew Koenig and Bjarne Stroustrup: C++: As Close to C as possible - but no closer. The C++ Report. Vol.1 No.7. July 1989. [10] Andrew Koenig and Bjarne Stroustrup: Exception Handling for C++ (revised). Proc USENIX C++ Conference, April 1990. Also, Journal of Object Oriented Programming, Vol.3 No.2, July/August 1990. pp.16-33. [11] Barbara Liskov et.al.: CLU Reference Manual. MIT/LCS/TR-225. [12] George Orwell: 1984. Secker and Warburg, London. 1949. [13] Martin Richards and Colin Whitby-Strevens: BCPL - The Language and Its Compiler. Cambridge University Press. 1980. [14] L.Rosler: The Evolution of C - Past and Future. AT&T Bell Laboratories Technical Journal. Vol.63 No.8 Part 2. October 1984. pp.1685-1700. [15] Ravi Sethi: Uniform Syntax for Type Expressions and Declarations. Software Practice & Experience, Vol.11. 1981. pp.623-628. [16] Bjarne Stroustrup: Adding Classes to C: An Exercise in Language Evolution. Software Practice & Experience, Vol.13. 1983. pp.139-61. [17] Bjarne Stroustrup: The C++ Programming Language. Addison-Wesley. 1986. [18] Bjarne Stroustrup: Multiple Inheritance for C++. Proc. EUUG Spring Conference, May 1987. Also USENIX Computer Systems, Vol.2 No 4, Fall 1989. [19] Bjarne Stroustrup and Jonathan Shopiro: A Set of C classes for Co-Routine Style Programming. Proc. USENIX C++ conference, Santa Fe. November 1987. pp.417-439. [20] Bjarne Stroustrup: Type-safe Linkage for C++. USENIX Computer Systems, Vol.1 No.4 Fall 1988. [21] Bjurne Stroustrup: Parameterized Type for C++. Proc. USENIX C++ Conference, Denver, October 1988. pp.1-18. Also, USENIX Computer Systems, Vol.2 No.1 Winter 1989. [22] Bjarne Stroustrup: Standardizing C++. The C++ Report. Vol.1 No.1. January 1989. [23] Bjarne Stroustrup: The Evolution of C++: 1985-1989. USENIX Computer Systems, Vol.2 No.3. Summer 1989. [24] P.M.Woodward and S.G.Bond: Algol 68-R Users Guide. Her Majesty's Stationery Office, London. 1974. [25] UNIX Time-Sharing System: Programmer's Manual. Research Version, Tenth Edition. AT&T Bell Laboratories, Murray Hill, New Jersy, February 1985. [26] Aake Wilkstroem: Functional Programming Using ML. Prentice-Hall, Englewood Cliffs, New Jersy. 1987. [27] X3 Secretariat: Standard - The C Language. X3J11/90-013. Computer and Business Equipment Manufactures Association, 311 First Street, NW, Suite 500, Washington, DC 20001, USA. Ссылки на источники по проектированию и развитию больших систем программного обеспечения можно найти в конце главы 11.  * КРАТКИЙ ОБЗОР С++ "Начнем с того, что вздернем всех этих законников, языковедов". ("Король Генрих VI", действие II) В этой главе содержится краткий обзор основных концепций и конструкций языка С++. Он служит для беглого знакомства с языком. Подробное описание возможностей языка и методов программирования на нем дается в следующих главах. Разговор ведется в основном вокруг абстракции данных и объектно-ориентированного программирования, но перечисляются и основные возможности процедурного программирования. 1.1 ВВЕДЕНИЕ Язык программирования С++ задумывался как язык, который будет: - лучше языка С; - поддерживать абстракцию данных; - поддерживать объектно-ориентированное программирование. В этой главе объясняется смысл этих фраз без подробного описания конструкций языка. $$1.2 содержит неформальное описание различий "процедурного", "модульного" и "объектно-ориентированного" программирования. Приведены конструкции языка, которые существенны для каждого из перечисленных стилей программирования. Свойственный С стиль программирования обсуждается в разделах "процедурное программирование и "модульное программирование". Язык С++ - "лучший вариант С". Он лучше поддерживает такой стиль программирования, чем сам С, причем это делается без потери какой-либо общности или эффективности по сравнению с С. В то же время язык C является подмножеством С++. Абстракция данных и объектно-ориентированное программирование рассматриваются как "поддержка абстракции данных" и "поддержка объектно- ориентированного программирования". Первая базируется на возможности определять новые типы и работать с ними, а вторая - на возможности задавать иерархию типов. $$1.3 содержит описание основных конструкций для процедурного и модульного программирования. В частности, определяются функции, указатели, циклы, ввод-вывод и понятие программы как совокупности раздельно транслируемых модулей. Подробно эти возможности описаны в главах 2, 3 и 4. $$1.4 содержит описание средств, предназначенных для эффективной реализации абстракции данных. В частности, определяются классы, простейший механизм контроля доступа, конструкторы и деструкторы, перегрузка операций, преобразования пользовательских типов, обработка особых ситуаций и шаблоны типов. Подробно эти возможности описаны в главах 5, 7, 8 и 9. $$1.5 содержит описание средств поддержки объектно-ориентированного программирования. В частности, определяются производные классы и виртуальные функции, обсуждаются некоторые вопросы реализации. Все это подробно изложено в главе 6. $$1.6 содержит описание определенных ограничений на пути совершенствования как языков программирования общего назначения вообще, так и С++ в частности. Эти ограничения связаны с эффективностью, с противоречащими друг другу требованиями разных областей приложения, проблемами обучения и необходимостью трансляции и выполнения программ в старых системах. Если какой-то раздел окажется для вас непонятным, настоятельно советуем прочитать соответствующие главы, а затем, ознакомившись с подробным описанием основных конструкций языка, вернуться к этой главе. Она нужна для того, чтобы можно было составить общее представление о языке. В ней недостаточно сведений, чтобы немедленно начать программировать. 1.2 Парадигмы программирования Объектно-ориентированное программирование - это метод программирования, способ написания "хороших" программ для множества задач. Если этот термин имеет какой-то смысл, то он должен подразумевать: такой язык программирования, который предоставляет хорошие возможности для объектно-ориентированного стиля программирования. Здесь следует указать на важные различия. Говорят, что язык поддерживает некоторый стиль программирования, если в нем есть такие возможности, которые делают программирование в этом стиле удобным (достаточно простым, надежным и эффективным). Язык не поддерживает некоторый стиль программирования, если требуются большие усилия или даже искусство, чтобы написать программу в этом стиле. Однако это не означает, что язык запрещает писать программы в этом стиле. Действительно, можно писать структурные программы на Фортране и объектно-ориентированные программы на С, но это будет пустой тратой сил, поскольку данные языки не поддерживают указанных стилей программирования. Поддержка языком определенной парадигмы (стиля) программирования явно проявляется в конкретных языковых конструкциях, рассчитанных на нее. Но она может проявляться в более тонкой, скрытой форме, когда отклонение от парадигмы диагностируется на стадии трансляции или выполнения программы. Самый очевидный пример - это контроль типов. Кроме того, языковая поддержка парадигмы может дополняться проверкой на однозначность и динамическим контролем. Поддержка может предоставляться и помимо самого языка, например, стандартными библиотеками или средой программирования. Нельзя сказать, что один язык лучше другого только потому, что в нем есть возможности, которые в другом отсутствуют. Часто бывает как раз наоборот. Здесь более важно не то, какими возможностями обладает язык, а то, насколько имеющиеся в нем возможности поддерживают избранный стиль программирования для определенного круга задач. Поэтому можно сформулировать следующие требования к языку: [1] Все конструкции языка должны естественно и элегантно определяться в нем. [2] Для решения определенной задачи должна быть возможность использовать сочетания конструкций, чтобы избежать необходимости вводить для этой цели новую конструкцию. [3] Должно быть минимальное число неочевидных конструкций специального назначения. [4] Конструкция должна допускать такую реализацию, чтобы в неиспользующей ее программе не возникло дополнительных расходов. [5] Пользователю достаточно знать только то множество конструкций, которое непосредственно используется в его программе. Первое требование апеллирует к логике и эстетическому вкусу. Два следующих выражают принцип минимальности. Два последних можно иначе сформулировать так: "то, чего вы не знаете, не сможет нанести вам вреда". С учетом ограничений, указанных в этих правилах, язык С++ проектировался для поддержки абстракции данных и объектно-ориентированного программирования в добавление к традиционному стилю С. Впрочем, это не значит, что язык требует какого-то одного стиля программирования от всех пользователей. Теперь перейдем к конкретным стилям программирования и посмотрим каковы основные конструкции языка, их поддерживающие. Мы не собираемся давать полное описание этих конструкций. 1.2.1 Процедурное программирование Первоначальной (и, возможно, наиболее используемой) парадигмой программирования было: Определите, какие процедуры вам нужны; используйте лучшие из известных вам алгоритмов! Ударение делалось на обработку данных с помощью алгоритма, производящего нужные вычисления. Для поддержки этой парадигмы языки предоставляли механизм передачи параметров и получения результатов функций. Литература, отражающая такой подход, заполнена рассуждениями о способах передачи параметров, о том, как различать параметры разных типов, о различных видах функций (процедуры, подпрограммы, макрокоманды, ...) и т.д. Первым процедурным языком был Фортран, а Алгол60, Алгол68, Паскаль и С продолжили это направление. Типичным примером хорошего стиля в таком понимании может служить функция извлечения квадратного корня. Для заданного параметра она выдает результат, который получается с помощью понятных математических операций: double sqrt ( double arg ) { // программа для вычисления квадратного корня } voide some_function () { double root = sqrt ( 2 ); // .. } Двойная наклонная черта // начинает комментарий, который продолжается до конца строки. При такой организации программы функции вносят определенный порядок в хаос различных алгоритмов. 1.2.2 Модульное программирование Со временем при в проектировании программ акцент сместился с организации процедур на организацию структур данных. Помимо всего прочего это вызвано и ростом размеров программ. Модулем обычно называют совокупность связанных процедур и тех данных, которыми они управляют. Парадигма программирования приобрела вид: Определите, какие модули нужны; поделите программу так, чтобы данные были скрыты в этих модулях Эта парадигма известна также как "принцип сокрытия данных". Если в языке нет возможности сгруппировать связанные процедуры вместе с данными, то он плохо поддерживает модульный стиль программирования. Теперь метод написания "хороших" процедур применяется для отдельных процедур модуля. Типичный пример модуля - определение стека. Здесь необходимо решить такие задачи: [1] Предоставить пользователю интерфейс для стека (например, функции push () и pop ()). [2] Гарантировать, что представление стека (например, в виде массива элементов) будет доступно лишь через интерфейс пользователя. [3] Обеспечивать инициализацию стека перед первым его использованием. Язык Модула-2 прямо поддерживает эту парадигму, тогда как С только допускает такой стиль. Ниже представлен на С возможный внешний интерфейс модуля, реализующего стек: // описание интерфейса для модуля, // реализующего стек символов: void push ( char ); char pop (); const int stack_size = 100; Допустим, что описание интерфейса находится в файле stack.h, тогда реализацию стека можно определить следующим образом: #include "stack.h" // используем интерфейс стека static char v [ stack_size ]; // ``static'' означает локальный // в данном файле/модуле static char * p = v; // стек вначале пуст void push ( char c ) { //проверить на переполнение и поместить в стек } char pop () { //проверить, не пуст ли стек, и считать из него } Вполне возможно, что реализация стека может измениться, например, если использовать для хранения связанный список. Пользователь в любом случае не имеет непосредственного доступа к реализации: v и p - статические переменные, т.е. переменные локальные в том модуле (файле), в котором они описаны. Использовать стек можно так: #include "stack.h" // используем интерфейс стека void some_function () { push ( 'c' ); char c = pop (); if ( c != 'c' ) error ( "невозможно" ); } Поскольку данные есть единственная вещь, которую хотят скрывать, понятие упрятывания данных тривиально расширяется до понятия упрятывания информации, т.е. имен переменных, констант, функций и типов, которые тоже могут быть локальными в модуле. Хотя С++ и не предназначался специально для поддержки модульного программирования, классы поддерживают концепцию модульности ($$5.4.3 и $$5.4.4). Помимо этого С++, естественно, имеет уже продемонстрированные возможности модульности, которые есть в С, т.е. представление модуля как отдельной единицы трансляции. 1.2.3 Абстракция данных Модульное программирование предполагает группировку всех данных одного типа вокруг одного модуля, управляющего этим типом. Если потребуются стеки двух разных видов, можно определить управляющий ими модуль с таким интерфейсом: class stack_id { /* ... */ }; // stack_id только тип // никакой информации о стеках // здесь не содержится stack_id create_stack ( int size ); // создать стек и возвратить // его идентификатор void push ( stack_id, char ); char pop ( stack_id ); destroy_stack ( stack_id ); // уничтожение стека Конечно такое решение намного лучше, чем хаос, свойственный традиционным, неструктурированным решениям, но моделируемые таким способом типы совершенно очевидно отличаются от "настоящих", встроенных. Каждый управляющий типом модуль должен определять свой собственный алгоритм создания "переменных" этого типа. Не существует универсальных правил присваивания идентификаторов, обозначающих объекты такого типа. У "переменных" таких типов не существует имен, которые были бы известны транслятору или другим системным программам, и эти "переменные" не подчиняются обычным правилам областей видимости и передачи параметров. Тип, реализуемый управляющим им модулем, по многим важным аспектам существенно отличается от встроенных типов. Такие типы не получают той поддержки со стороны транслятора (разного вида контроль), которая обеспечивается для встроенных типов. Проблема здесь в том, что программа формулируется в терминах небольших (одно-два слова) дескрипторов объектов, а не в терминах самих объектов ( stack_id может служить примером такого дескриптора). Это означает, что транслятор не сможет отловить глупые, очевидные ошибки, вроде тех, что допущены в приведенной ниже функции: void f () { stack_id s1; stack_id s2; s1 = create_stack ( 200 ); // ошибка: забыли создать s2 push ( s1,'a' ); char c1 = pop ( s1 ); destroy_stack ( s2 ); // неприятная ошибка // ошибка: забыли уничтожить s1 s1 = s2; // это присваивание является по сути // присваиванием указателей, // но здесь s2 используется после уничтожения } Иными словами, концепция модульности, поддерживающая парадигму упрятывания данных, не запрещает такой стиль программирования, но и не способствует ему. В языках Ада, Clu, С++ и подобных им эта трудность преодолевается благодаря тому, что пользователю разрешается определять свои типы, которые трактуются в языке практически так же, как встроенные. Такие типы обычно называют абстрактными типами данных, хотя лучше, пожалуй, их называть просто пользовательскими. Более строгим определением абстрактных типов данных было бы их математическое определение. Если бы удалось его дать, то, что мы называем в программировании типами, было бы конкретным представлением действительно абстрактных сущностей. Как определить "более абстрактные" типы, показано в $$4.6. Парадигму же программирования можно выразить теперь так: Определите, какие типы вам нужны; предоставьте полный набор операций для каждого типа. Если нет необходимости в разных объектах одного типа, то стиль программирования, суть которого сводится к упрятыванию данных, и следование которому обеспечивается с помощью концепции модульности, вполне адекватен этой парадигме. Арифметические типы, подобные типам рациональных и комплексных чисел, являются типичными примерами пользовательских типов: class complex { double re, im; public: complex(double r, double i) { re=r; im=i; } complex(double r) // преобразование float->complex { re=r; im=0; } friend complex operator+(complex, complex); friend complex operator-(complex, complex); // вычитание friend complex operator-(complex) // унарный минус friend complex operator*(complex, complex); friend complex operator/(complex, complex); // ... }; Описание класса (т.е. определяемого пользователем типа) complex задает представление комплексного числа и набор операций с комплексными числами. Представление является частным (private): re и im доступны только для функций, указанных в описании класса complex. Подобные функции могут быть определены так: complex operator + ( complex a1, complex a2 ) { return complex ( a1.re + a2.re, a1.im + a2.im ); } и использоваться следующим образом: void f () { complex a = 2.3; complex b = 1 / a; complex c = a + b * complex ( 1, 2.3 ); // ... c = - ( a / b ) + 2; } Большинство модулей (хотя и не все) лучше определять как пользовательские типы. 1.2.4 Пределы абстракции данных Абстрактный тип данных определяется как некий "черный ящик". После своего определения он по сути никак не взаимодействует с программой. Его никак нельзя приспособить для новых целей, не меняя определения. В этом смысле это негибкое решение. Пусть, например, нужно определить для графической системы тип shape (фигура). Пока считаем, что в системе могут быть такие фигуры: окружность (circle), треугольник (triangle) и квадрат (square). Пусть уже есть определения точки и цвета: class point { /* ... */ }; class color { /* ... */ }; Тип shape можно определить следующим образом: enum kind { circle, triangle, square }; class shape { point center; color col; kind k; // представление фигуры public: point where () { return center; } void move ( point to ) { center = to; draw (); } void draw (); void rotate ( int ); // еще некоторые операции }; "Поле типа" k необходимо для того, чтобы такие операции, как draw () и rotate (), могли определять, с какой фигурой они имеют дело (в языках вроде Паскаля можно использовать для этого запись с вариантами, в которой k является полем-дескриминантом). Функцию draw () можно определить так: void shape :: draw () { switch ( k ) { case circle: // рисование окружности break; case triangle: // рисование треугольника break; case square: // рисование квадрата break; } } Это не функция, а кошмар. В ней нужно учесть все возможные фигуры, какие только есть. Поэтому она дополняется новыми операторами, как только в системе появляется новая фигура. Плохо то, что после определения новой фигуры нужно проверить и, возможно, изменить все старые операции класса. Поэтому, если вам недоступен исходный текст каждой операции класса, ввести новую фигуру в систему просто невозможно. Появление любой новой фигуры приводит к манипуляциям с текстом каждой существенной операции класса. Требуется достаточно высокая квалификация, чтобы справиться с этой задачей, но все равно могут появиться ошибки в уже отлаженных частях программы, работающих со старыми фигурами. Возможность выбора представления для конкретной фигуры сильно сужается, если требовать, чтобы все ее представления укладывались в уже заданный формат, специфицированный общим определением фигуры (т.е. определением типа shape). 1.2.5 Объектно-ориентированное программирование Проблема состоит в том, что мы не различаем общие свойства фигур (например, фигура имеет цвет, ее можно нарисовать и т.д.) и свойства конкретной фигуры (например, окружность - это такая фигура, которая имеет радиус, она изображается с помощью функции, рисующей дуги и т.д.). Суть объектно-ориентированного программирования в том, что оно позволяет выражать эти различия и использует их. Язык, который имеет конструкции для выражения и использования подобных различий, поддерживает объектно-ориентированное программирование. Все другие языки не поддерживают его. Здесь основную роль играет механизм наследования, заимствованный из языка Симула. Вначале определим класс, задающий общие свойства всех фигур: class shape { point center; color col; // ... public: point where () { return center; } void move ( point to ) { center = to; draw(); } virtual void draw (); virtual void rotate ( int ); // ... }; Те функции, для которых можно определить заявленный интерфейс, но реализация которых (т.е. тело с операторной частью) возможна только для конкретных фигур, отмечены служебным словом virtual (виртуальные). В Симуле и С++ виртуальность функции означает: "функция может быть определена позднее в классе, производном от данного". С учетом такого определения класса можно написать общие функции, работающие с фигурами: void rotate_all ( shape v [], int size, int angle ) // повернуть все элементы массива "v" размера "size" // на угол равный "angle" { int i = 0; while ( i<size ) { v [ i ] . rotate ( angle ); i = i + 1; } } Для определения конкретной фигуры следует указать, прежде всего, что это - именно фигура и задать ее особые свойства (включая и виртуальные функции): class circle : public shape { int radius; public: void draw () { /* ... */ }; void rotate ( int ) {} // да, пока пустая функция }; В языке С++ класс circle называется производным по отношению к классу shape, а класс shape называется базовым для класса circle. Возможна другая терминология, использующая названия "подкласс" и "суперкласс" для классов circle и shape соответственно. Теперь парадигма программирования формулируется так: Определите, какой класс вам необходим; предоставьте полный набор операций для каждого класса; общность классов выразите явно с помощью наследования. Если общность между классами отсутствует, вполне достаточно абстракции данных. Насколько применимо объектно-ориентированное программирование для данной области приложения определяется степенью общности между разными типами, которая позволяет использовать наследование и виртуальные функции. В некоторых областях, таких, например, как интерактивная графика, есть широкий простор для объектно-ориентированного программирования. В других областях, в которых используются традиционные арифметические типы и вычисления над ними, трудно найти применение для более развитых стилей программирования, чем абстракция данных. Здесь средства, поддерживающие объектно-ориентированное программирование, очевидно, избыточны. Нахождение общности среди отдельных типов системы представляет собой нетривиальный процесс. Степень такой общности зависит от способа проектирования системы. В процессе проектирования выявление общности классов должно быть постоянной целью. Она достигается двумя способами: либо проектированием специальных классов, используемых как "кирпичи" при построении других, либо поиском похожих классов для выделения их общей части в один базовый класс. С попытками объяснить, что такое объектно-ориентированное программирование, не используя конкретных конструкций языков программирования, можно познакомиться в работах [2] и [6], приведенных в списке литературы в главе 11. Итак, мы указали, какую минимальную поддержку должен обеспечивать язык программирования для процедурного программирования, для упрятывания данных, абстракции данных и объектно-ориентированного программирования. Теперь несколько подробнее опишем средства языка, хотя и не самые существенные, но позволяющие более эффективно реализовать абстракцию данных и объектно-ориентированное программирование. 1.3 "Улучшенный С" Минимальная поддержка процедурного программирования включает функции, арифметические операции, выбирающие операторы и циклы. Помимо этого должны быть предоставлены операции ввода- вывода. Базовые языковые средства С++ унаследовал от С (включая указатели), а операции ввода-вывода предоставляются библиотекой. Самая зачаточная концепция модульности реализуется с помощью механизма раздельной трансляции. 1.3.1 Программа и стандартный вывод Самая маленькая программа на С++ выглядит так: main () { } В этой программе определяется функция, называемая main, которая не имеет параметров и ничего не делает. Фигурные скобки { и } используются в С++ для группирования операторов. В данном случае они обозначают начало и конец тела (пустого) функции main. В каждой программе на С++ должна быть своя функция main(), и программа начинается с выполнения этой функции. Обычно программа выдает какие-то результаты. Вот программа, которая выдает приветствие Hello, World! (Всем привет!): #include <iostream.h> int main () { cout << "Hello, World!\n"; } Строка #include <iostream.h> сообщает транслятору, что надо включить в программу описания, необходимые для работы стандартных потоков ввода- вывода, которые находятся в iostream.h. Без этих описаний выражение cout << "Hello, World!\n" не имело бы смысла. Операция << ("выдать") записывает свой второй параметр в первый параметр. В данном случае строка "Hello, World!\n" записывается в стандартный выходной поток cout. Строка - это последовательность символов, заключенная в двойные кавычки. Два символа: обратной дробной черты \ и непосредственно следующий за ним - обозначают некоторый специальный символ. В данном случае \n является символом конца строки (или перевода строки), поэтому он выдается после символов Hello, world! Целое значение, возвращаемое функцией main(), если только оно есть, считается возвращаемым системе значением программы. Если ничего не возвращается, система получит какое-то "мусорное" значение. Средства ввода/вывода потоковой библиотеки подробно описываются в главе 10. 1.3.2 Переменные и арифметические операции Каждое имя и каждое выражение обязаны иметь тип. Именно тип определяет операции, которые могут выполняться над ними. Например, в описании int inch; говорится, что inch имеет тип int, т.е. inch является целой переменной. Описание - это оператор, который вводит имя в программу. В описании указывается тип имени. Тип, в свою очередь, определяет как правильно использовать имя или выражение. Основные типы, наиболее приближенные к "аппаратной реальности" машины, таковы: char short int long Они представляют целые числа. Следующие типы: float double long double представляют числа с плавающей точкой. Переменная типа char имеет размер, нужный для хранения одного символа на данной машине (обычно это один байт). Переменная int имеет размер, необходимый для целой арифметики на данной машине (обычно это одно слово). Следующие арифметические операции можно использовать над любым сочетанием перечисленных типов: + (плюс, унарный и бинарный) - (минус, унарный и бинарный) * (умножение) / (деление) % (остаток от деления) То же верно для операций отношения: == (равно) != (не равно) < (меньше чем) <= (меньше или равно) >= (больше или равно) Для операций присваивания и арифметических операций в С++ выполняются все осмысленные преобразования основных типов, чтобы их можно было неограниченно использовать любые их сочетания: double d; int i; short s; // ... d = d + i; i = s * i; Символ = обозначает обычное присваивание. 1.3.3 Указатели и массивы Массив можно описать так: char v [ 10 ]; // массив из 10 символов Описание указателя имеет такой вид: char * p; // указатель на символ Здесь [] означает "массив из", а символ * означает "указатель на". Значение нижней границы индекса для всех массивов равно нулю, поэтому v имеет 10 элементов: v [ 0 ] ... v [ 9 ]. Переменная типа указатель может содержать адрес объекта соответствующего типа: p = & v [ 3 ]; // p указывает на 4-й элемент массива v Унарная операция & означает взятие адреса. 1.3.4 Условные операторы и циклы В С++ есть традиционный набор выбирающих операторов и циклов. Ниже приводятся примеры операторов if, switch и while. В следующем примере показано преобразование дюйма в сантиметр и обратно. Предполагается, что во входном потоке значение в сантиметрах завершается символом i, а значение в дюймах - символом c: #include <iostream.h> int main () { const float fac = 2.54; float x, in, cm; char ch = 0; cout << "enter length: "; cin >> x; // ввод числа с плавающей точкой cin >> ch // ввод завершающего символа if ( ch == 'i' ) { // дюйм in = x; cm = x * fac; } else if ( ch == 'c' ) { // сантиметры in = x / fac; cm = x; } else in = cm = 0; cout << in << " in = " << cm << " cm\n"; } Операция >> ("ввести из") используется как оператор ввода; cin является стандартным входным потоком. Тип операнда, расположенного справа от операции >>, определяет, какое значение вводится; оно записывается в этот операнд. Оператор switch (переключатель) сравнивает значение с набором констант. Проверку в предыдущем примере можно записать так: switch ( ch ) { case 'i': in = x; cm = x * fac; break; case 'c': in = x / fac; cm = x; break; default: in = cm = 0; break; } Операторы break используются для выхода из переключателя. Все константы вариантов должны быть различны. Если сравниваемое значение не совпадает ни с одной из них, выполняется оператор с меткой default. Вариант default может и отсутствовать. Приведем запись, задающую копирование 10 элементов одного массива в другой: int v1 [ 10 ]; int v2 [ 10 ]; // ... for ( int i=0; i<10; i++ ) v1 [ i ] = v2 [ i ]; Словами это можно выразить так: "Начать с i равного нулю, и пока i меньше 10, копировать i-тый элемент и увеличивать i." Инкремент (++) переменной целого типа просто сводится к увеличению на 1. 1.3.5 Функции Функция - это поименованная часть программы, которая может вызываться из других частей программы столько раз, сколько необходимо. Приведем программу, выдающую степени числа два: extern float pow ( float, int ); // pow () определена в другом месте int main () { for ( int i=0; i<10; i++ ) cout << pow ( 2, i ) << '\n'; } Первая строка является описанием функции. Она задает pow как функцию с параметрами типа float и int, возвращающую значение типа float. Описание функции необходимо для ее вызова, ее определение находится в другом месте. При вызове функции тип каждого фактического параметра сверяется с типом, указанным в описании функции, точно так же, как если бы инициализировалась переменная описанного типа. Это гарантирует надлежащую проверку и преобразования типов. Например, вызов функции pow(12.3,"abcd") транслятор сочтет ошибочным, поскольку "abcd" является строкой, а не параметром типа int. В вызове pow(2,i) транслятор преобразует целую константу (целое 2) в число с плавающей точкой (float), как того требует функция. Функция pow может быть определена следующим образом: float pow ( float x, int n ) { if ( n < 0 ) error ( "ошибка: для pow () задан отрицательный показатель"); switch ( n ) { case 0: return 1; case 1: return x; default: return x * pow ( x, n-1 ); } } Первая часть определения функции задает ее имя, тип возвращаемого значения (если оно есть), а также типы и имена формальных параметров (если они существуют). Значение возвращается из функции с помощью оператора return. Разные функции обычно имеют разные имена, но функциям, выполняющим сходные операции над объектами разных типов, лучше дать одно имя. Если типы параметров таких функций различны, то транслятор всегда может разобраться, какую функцию нужно вызывать. Например, можно иметь две функции возведения в степень: одну - для целых чисел, а другую - для чисел с плавающей точкой: int pow ( int, int ); double pow ( double, double ); //... x = pow ( 2,10 ); // вызов pow ( int, int ) y = pow ( 2.0, 10.0 );// вызов pow ( double, double ) Такое многократное использование имени называется перегрузкой имени функции или просто перегрузкой; перегрузка рассматривается особо в главе 7. Параметры функции могут передаваться либо "по значению", либо "по ссылке". Рассмотрим определение функции, которая осуществляет взаимообмен значений двух целых переменных. Если используется стандартный способ передачи параметров по значению, то придется передавать указатели: void swap ( int * p, int * q ) { int t = * p; * p = * q; * q = t; } Унарная операция * называется косвенностью (или операцией разыменования), она выбирает значение объекта, на который настроен указатель. Функцию можно вызывать следующим образом: void f ( int i, int j ) { swap ( & i, & j ); } Если использовать передачу параметра по ссылке, можно обойтись без явных операций с указателем: void swap (int & r1, int & r2 ) { int t = r1; r1 = r2; r2 = t; } void g ( int i, int j ) { swap ( i, j ); } Для любого типа T запись T& означает "ссылка на T". Ссылка служит синонимом той переменной, которой она инициализировалась. Отметим, что перегрузка допускает сосуществование двух функций swap в одной программе. 1.3.6 Модули Программа С++ почти всегда состоит из нескольких раздельно транслируемых "модулей". Каждый "модуль" обычно называется исходным файлом, но иногда - единицей трансляции. Он состоит из последовательности описаний типов, функций, переменных и констант. Описание extern позволяет из одного исходного файла ссылаться на функцию или объект, определенные в другом исходном файле. Например: extern "C" double sqrt ( double ); extern ostream cout; Самый распространенный способ обеспечить согласованность описаний внешних во всех исходных файлах - поместить такие описания в специальные файлы, называемые заголовочными. Заголовочные файлы можно включать во все исходные файлы, в которых требуются описания внешних. Например, описание функции sqrt хранится в заголовочном файле стандартных математических функций с именем math.h, поэтому, если нужно извлечь квадратный корень из 4, можно написать: #include <math.h> //... x = sqrt ( 4 ); Поскольку стандартные заголовочные файлы могут включаться во многие исходные файлы, в них нет описаний, дублирование которых могло бы вызвать ошибки. Так, тело функции присутствует в таких файлах, если только это функция-подстановка, а инициализаторы указаны только для констант ($$4.3). Не считая таких случаев, заголовочный файл обычно служит хранилищем для типов, он предоставляет интерфейс между раздельно транслируемыми частями программы. В команде включения заключенное в угловые скобки имя файла (в нашем примере - <math.h>) ссылается на файл, находящийся в стандартном каталоге включаемых файлов. Часто это - каталог /usr/include/CC. Файлы, находящиеся в других каталогах, обозначаются своими путевыми именами, взятыми в кавычки. Поэтому в следующих командах: #include "math1.h" #include "/usr/bs/math2.h" включаются файл math1.h из текущего каталога пользователя и файл math2.h из каталога /usr/bs. Приведем небольшой законченный пример, в котором строка определяется в одном файле, а печатается в другом. В файле header.h определяются нужные типы: // header.h extern char * prog_name; extern void f (); Файл main.c является основной программой: // main.c #include "header.h" char * prog_name = "примитивный, но законченный пример"; int main () { f (); } а строка печатается функцией из файла f.c: // f.c #include <stream.h> #include "header.h" void f () { cout << prog_name << '\n'; } При запуске транслятора С++ и передаче ему необходимых файлов-параметров в различных реализациях могут использоваться разные расширения имен для программ на С++. На машине автора трансляция и запуск программы выглядит так: $ CC main.c f.c -o silly $ silly примитивный, но законченный пример $ Кроме раздельной трансляции концепцию модульности в С++ поддерживают классы ($$5.4). 1.4 Поддержка абстракции данных Поддержка программирования с абстракцией данных в основном сводится к возможности определить набор операций (функции и операции) над типом. Все обращения к объектам этого типа ограничиваются операциями из заданного набора. Однако, имея такие возможности, программист скоро обнаруживает, что для удобства определения и использования новых типов нужны еще некоторые расширения языка. Хорошим примером такого расширения является перегрузка операций. 1.4.1 Инициализация и удаление Когда представление типа скрыто, необходимо дать пользователю средства для инициализации переменных этого типа. Простейшее решение - до использования переменной вызывать некоторую функцию для ее инициализации. Например: class vector { // ... public: void init ( init size ); // вызов init () перед первым // использованием объекта vector // ... }; void f () { vector v; // пока v нельзя использовать v.init ( 10 ); // теперь можно } Но это некрасивое и чреватое ошибками решение. Будет лучше, если создатель типа определит для инициализации переменных некоторую специальную функцию. Если такая функция есть, то две независимые операции размещения и инициализации переменной совмещаются в одной (иногда ее называют инсталляцией или просто построением). Функция инициализации называется конструктором. Конструктор выделяется среди всех прочих функций данного класса тем, что имеет такое же имя, как и сам класс. Если объекты некоторого типа строятся нетривиально, то нужна еще одна дополнительная операция для удаления их после последнего использования. Функция удаления в С++ называется деструктором. Деструктор имеет то же имя, что и его класс, но перед ним стоит символ ~ (в С++ этот символ используется для операции дополнения). Приведем пример: class vector { int sz; // число элементов int * v; // указатель на целые public: vector ( int ); // конструктор ~vector (); // деструктор int& operator [] ( int index ); // операция индексации }; Конструктор класса vector можно использовать для контроля над ошибками и выделения памяти: vector::vector ( int s ) { if ( s <= 0 ) error ( "недопустимый размер вектора" ); sz = s; v = new int [ s ]; // разместить массив из s целых } Деструктор класса vector освобождает использовавшуюся память: vector::~vector () { delete [] v; // освободить массив, на который // настроен указатель v } От реализации С++ не требуется освобождения выделенной с помощью new памяти, если на нее больше не ссылается ни один указатель (иными словами, не требуется автоматическая "сборка мусора"). В замен этого можно без вмешательства пользователя определить в классе собственные функции управления памятью. Это типичный способ применения конструкторов и деструкторов, хотя есть много не связанных с управлением памятью применений этих функций (см., например, $$9.4). 1.4.2 Присваивание и инициализация Для многих типов задача управления ими сводится к построению и уничтожению связанных с ними объектов, но есть типы, для которых этого мало. Иногда необходимо управлять всеми операциями копирования. Вернемся к классу vector: void f () { vector v1 ( 100 ); vector v2 = v1; // построение нового вектора v2, // инициализируемого v1 v1 = v2; // v2 присваивается v1 // ... } Должна быть возможность определить интерпретацию операций инициализации v2 и присваивания v1. Например, в описании: class vector { int * v; int sz; public: // ... void operator = ( const vector & ); // присваивание vector ( const vector & ); // инициализация }; указывается, что присваивание и инициализация объектов типа vector должны выполняться с помощью определенных пользователем операций. Присваивание можно определить так: void vector::operator = ( const vector & a ) // контроль размера и копирование элементов { if ( sz != a.sz ) error ( "недопустимый размер вектора для =" ); for ( int i = 0; i < sz; i++ ) v [ i ] = a.v [ i ]; } Поскольку эта операция использует для присваивания "старое значение" вектора, операция инициализации должна задаваться другой функцией, например, такой: vector::vector ( const vector & a ) // инициализация вектора значением другого вектора { sz = a.sz; // размер тот же v = new int [ sz ]; // выделить память для массива for ( int i = 0; i < sz; i++ ) //копирование элементов v [ i ] = a.v [ i ]; } В языке С++ конструктор вида T(const T&) называется конструктором копирования для типа T. Любую инициализацию объектов типа T он выполняет с помощью значения некоторого другого объекта типа T. Помимо явной инициализации конструкторы вида T(const T&) используются для передачи параметров по значению и получения возвращаемого функцией значения. 1.4.3 Шаблоны типа Зачем программисту может понадобиться определить такой тип, как вектор целых чисел? Как правило, ему нужен вектор из элементов, тип которых неизвестен создателю класса Vector. Следовательно, надо суметь определить тип вектора так, чтобы тип элементов в этом определении участвовал как параметр, обозначающий "реальные" типы элементов: template < class T > class Vector { // вектор элементов типа T T * v; int sz; public: Vector ( int s ) { if ( s <= 0 ) error ( "недопустимый для Vector размер" ); v = new T [ sz = s ]; // выделить память для массива s типа T } T & operator [] ( int i ); int size () { return sz; } // ... }; Таково определение шаблона типа. Он задает способ получения семейства сходных классов. В нашем примере шаблон типа Vector показывает, как можно получить класс вектор для заданного типа его элементов. Это описание отличается от обычного описания класса наличием начальной конструкции template<class T>, которая и показывает, что описывается не класс, а шаблон типа с заданным параметром-типом (здесь он используется как тип элементов). Теперь можно определять и использовать вектора разных типов: void f () { Vector < int > v1 ( 100 ); // вектор из 100 целых Vector < complex > v2 ( 200 ); // вектор из 200 // комплексных чисел v2 [ i ] = complex ( v1 [ x ], v1 [ y ] ); // ... } Возможности, которые реализует шаблон типа, иногда называются параметрическими типами или генерическими объектами. Оно сходно с возможностями, имеющимися в языках Clu и Ада. Использование шаблона типа не влечет за собой каких-либо дополнительных расходов времени по сравнению с использованием класса, в котором все типы указаны непосредственно. 1.4.4 Обработка особых ситуаций По мере роста программ, а особенно при активном использовании библиотек появляется необходимость стандартной обработки ошибок (или, в более широком смысле, "особых ситуаций"). Языки Ада, Алгол-68 и Clu поддерживают стандартный способ обработки особых ситуаций. Снова вернемся к классу vector. Что нужно делать, когда операции индексации передано значение индекса, выходящее за границы массива? Создатель класса vector не знает, на что рассчитывает пользователь в таком случае, а пользователь не может обнаружить подобную ошибку (если бы мог, то эта ошибка вообще не возникла бы). Выход такой: создатель класса обнаруживает ошибку выхода за границу массива, но только сообщает о ней неизвестному пользователю. Пользователь сам принимает необходимые меры. Например: class vector { // определение типа возможных особых ситуаций class range { }; // ... }; Вместо вызова функции ошибки в функции vector::operator[]() можно перейти на ту часть программы, в которой обрабатываются особые ситуации. Это называется "запустить особую ситуацию" ("throw the exception"): int & vector::operator [] ( int i ) { if ( i < 0 || sz <= i ) throw range (); return v [ i ]; } В результате из стека будет выбираться информация, помещаемая туда при вызовах функций, до тех пор, пока не будет обнаружен обработчик особой ситуации с типом range для класса вектор (vector::range); он и будет выполняться. Обработчик особых ситуаций можно определить только для специального блока: void f ( int i ) { try { // в этом блоке обрабатываются особые ситуации // с помощью определенного ниже обработчика vector v ( i ); // ... v [ i + 1 ] = 7; // приводит к особой ситуации range // ... g (); // может привести к особой ситуации range // на некоторых векторах } catch ( vector::range ) { error ( "f (): vector range error" ); return; } } Использование особых ситуаций делает обработку ошибок более упорядоченной и понятной. Обсуждение и подробности отложим до главы 9. 1.4.5 Преобразования типов Определяемые пользователем преобразования типа, например, такие, как преобразование числа с плавающей точкой в комплексное, которое необходимо для конструктора complex(double), оказались очень полезными в С++. Программист может задавать эти преобразования явно, а может полагаться на транслятор, который выполняет их неявно в том случае, когда они необходимы и однозначны: complex a = complex ( 1 ); complex b = 1; // неявно: 1 -> complex ( 1 ) a = b + complex ( 2 ); a = b + 2; // неявно: 2 -> complex ( 2) Преобразования типов нужны в С++ потому, что арифметические операции со смешанными типами являются нормой для языков, используемых в числовых задачах. Кроме того, большая часть пользовательских типов, используемых для "вычислений" (например, матрицы, строки, машинные адреса) допускает естественное преобразование в другие типы (или из других типов). Преобразования типов способствуют более естественной записи программы: complex a = 2; complex b = a + 2; // это означает: operator + ( a, complex ( 2 )) b = 2 + a; // это означает: operator + ( complex ( 2 ), a ) В обоих случаях для выполнения операции "+" нужна только одна функция, а ее параметры единообразно трактуются системой типов языка. Более того, класс complex описывается так, что для естественного и беспрепятственного обобщения понятия числа нет необходимости что-то изменять для целых чисел. 1.4.6 Множественные реализации Основные средства, поддерживающие объектно-ориентированное программирование, а именно: производные классы и виртуальные функции,- можно использовать и для поддержки абстракции данных, если допустить несколько реализаций одного типа. Вернемся к примеру со стеком: template < class T > class stack { public: virtual void push ( T ) = 0; // чистая виртуальная функция virtual T pop () = 0; // чистая виртуальная функция }; Обозначение =0 показывает, что для виртуальной функции не требуется никакого определения, а класс stack является абстрактным, т.е. он может использоваться только как базовый класс. Поэтому стеки можно использовать, но не создавать: class cat { /* ... */ }; stack < cat > s; // ошибка: стек - абстрактный класс void some_function ( stack <cat> & s, cat kitty ) // нормально { s.push ( kitty ); cat c2 = s.pop (); // ... } Поскольку интерфейс стека ничего не сообщает о его представлении, от пользователей стека полностью скрыты детали его реализации. Можно предложить несколько различных реализаций стека. Например, стек может быть массивом: template < class T > class astack : public stack < T > { // истинное представление объекта типа стек // в данном случае - это массив // ... public: astack ( int size ); ~astack (); void push ( T ); T pop (); }; Можно реализовать стек как связанный список: template < class T > class lstack : public stack < T > { // ... }; Теперь можно создавать и использовать стеки: void g () { lstack < cat > s1 ( 100 ); astack < cat > s2 ( 100 ); cat Ginger; cat Snowball; some_function ( s1, Ginger ); some_function ( s2, Snowball ); } О том, как представлять стеки разных видов, должен беспокоиться только тот, кто их создает (т.е. функция g()), а пользователь стека (т.е. автор функции some_function()) полностью огражден от деталей их реализации. Платой за подобную гибкость является то, что все операции над стеками должны быть виртуальными функциями. 1.5 Поддержка объектно-ориентированного программиров