52393

С++ для начинающих

Книга

Информатика, кибернетика и программирование

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

Русский

2014-02-15

2.85 MB

4 чел.

С++ для начинающих

Посвящается Бет,

благодаря которой стала возможна эта книга,

да и все остальное тоже.

----------

Посвящается Даниэлю и Анне,

которым открыты все возможности

-- SBL

Посвящается Марку и маме,

за их любовь и поддержку безо всяких условий

--JL

 

Ïðåäèñëîâèå

Между выходом второго и третьего издания “С++ для начинающих” произошло довольно много событий. Одним из самых значительных стало появление международного стандарта. Он не только добавил в язык С++ новые возможности, среди которых обработка исключений, идентификация типов во время выполнения, пространство имен, встроенный булевский тип данных, новый синтаксис приведения типов, но также существенно изменил и расширил имеющиеся – шаблоны, механизм классов, поддерживающий объектную и объектно-ориентированную парадигму программирования, вложенные типы и разрешение перегруженных функций. Еще более важным событием стало включение в состав стандарта С++ обширной библиотеки, содержащей, в частности, то, что ранее называлось Standard Template Library (STL). В эту стандартную библиотеку входят новый тип string, последовательные и ассоциативные контейнеры, такие, как vector, list, map, set, и обширный набор обобщенных алгоритмов, которые могут применяться ко всем этим типам данных. Появилось не просто много нового материала, нуждающегося в описании, но фактически изменился сам способ мышления при программировании на С++. Короче говоря, можно считать, что С++ изобретен заново, поэтому третье издание нашей книги “C++ для начинающих” полностью переработано.

В третьем издании не только коренным образом поменялся наш подход к С++, изменились и авторы. Прежде всего, авторский коллектив удвоился и стал интернациональным, хотя корни его по-прежнему на североамериканском континенте: Стен (Stan) американец, а Жози (Josйe) канадка. Двойное авторство отражает деление сообщества программистов С++ на две части: Стен в настоящее время занимается разработкой приложений на C++ в области трехмерной графики и анимации для Walt Disney Feature Animation, а Жози принимает участие в развитии самого языка С++, являясь председателем рабочей группы по ядру языка в комитете по стандартизации и одним из разработчиков компилятора С++ в IBM Canada Laboratory.

Стен работает над С++ с 1984 года. Он был одним из членов первоначальной команды, трудившейся в Bell Laboratories под руководством Бьерна Страуструпа (Bjarne Stroustrup), изобретателя языка. Стен принимал участие в разработке cfront, оригинальной реализации С, с версии 1.1 в 1986 году до версии 3.0, и возглавлял проект при работе над версиями 2.1 и 3.0. После этого он работал под началом Страуструпа над проектом, посвященным исследованиям объектной модели программной среды разработки на C++.

Жози – член команды, работающей над компилятором С++ в IBM Canada Laboratory на протяжении восьми лет. С 1990 года она входит в состав комитета по стандартизации. Три года она была вице-президентом комитета и четыре года – председателем рабочей группы по ядру языка.

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

Ñòðóêòóðà êíèãè

“C++ для начинающих” содержит обстоятельное введение в международный стандарт С++. Мы включили в название книги слова “для начинающих” потому, что последовательно придерживались учебного подхода к описанию языка С++; однако название не предполагает упрощенного или облегченного изложения материала. Такие аспекты программирования, как обработка исключений, контейнерные типы, объектно-ориентированный подход и т.п., представлены в книге в контексте решения конкретных задач. Правила языка, например разрешение перегруженных функций или преобразования типов в объектно-ориентированном программировании, рассматриваются столь подробно, что во вводном курсе это может показаться неуместным. Но мы уверены, что такое освещение необходимо для практического применения языка. Материал книги не нужно стараться усвоить “за один проход”: мы предполагаем, что читатель будет периодически возвращаться к ранее прочитанным разделам. Если некоторые из них покажутся вам слишком трудными или просто скучными, отложите их на время. (Подозрительные разделы мы помечали значком А.)

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

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

Главы 1 и 2 представляют собой полное введение в язык С++ и его обзор. Назначение первой части – как можно быстрее познакомить читателя с понятиями и средствами данного языка, а также основными принципами написания программ.

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

В главе 1 представлены базовые элементы языка: встроенные типы данных, переменные, выражения, инструкции и функции. Мы увидим минимальную законченную программу на С++, обсудим вопросы компиляции, коснемся препроцессора и поддержки ввода/вывода. В этой главе читатель найдет ряд простых, но законченных С++ программ, которые можно откомпилировать и выполнить. Глава 2 посвящена механизму классов и тому, как с его помощью поддержаны парадигмы объектного и объектно-ориентированного программирования. Оба эти подхода иллюстрируются развитием реализации массива как абстрактного типа. Кроме того, приводится краткая информация о шаблонах, пространствах имен, обработке исключений и о поддержке стандартной библиотекой общих контейнерных типов и методов обобщенного (generic) программирования. Материал в этой главе излагается весьма стремительно, и потому некоторым читателям она может показаться трудной. Мы рекомендуем таким читателям просмотреть вторую главу “по диагонали” и вернуться к ней впоследствии.

Фундаментальной особенностью С++ является возможность расширять язык, определяя новые типы данных, которые могут использоваться с тем же удобством и гибкостью, что и встроенные. Первым шагом к овладению этим искусством является знание базового языка. Часть II (главы 3-6) посвящена рассмотрению языка на этом уровне.

В главе 3 представлены встроенные и составные типы, предопределенные в языке, а также типы string, complex и vector из стандартной библиотеки С++. Эти типы составляют основные “кирпичики”, из которых строятся все программы. В главе 4 детально освещаются выражения языка – арифметические, условные, присваивания. Инструкции языка, которые являются мельчайшими независимыми единицами С++ программы, представлены в главе 5. Контейнерные типы данных стали предметом главы 6. Вместо простого перечисления совокупности поддерживаемых ими операций, мы иллюстрируем операции на примере построения системы текстового поиска.

Главы 7-12 (часть III) посвящены процедурно-ориентированному программированию на С++. В главе 7 представлен механизм функций. Функция инкапсулирует набор операций, составляющих единую задачу, как, например, print(). (Круглые скобки после имени говорят о том, что мы имеем дело с функцией.) Такие понятия, как область видимости и время жизни переменных, рассматриваются в главе 8. Обзор механизма функций продолжен в главе 9: речь пойдет о перегрузке функций, которая позволяет присвоить одно и то же имя нескольким функциям, выполняющим похожие, но по-разному реализованные операции. Например, можно определить целый набор функций print() для печати данных разных типов. В главе 10 представлено понятие шаблона функции и приведены примеры его использования. Шаблон функции предназначен для автоматической генерации потенциально бесконечного множества экземпляров функций, отличающихся только типами данных.

С++ поддерживает обработку исключений. Об исключении говорят, когда в программе возникает нестандартная ситуация, такая, например, как нехватка свободной памяти. В том месте программы, где это происходит, возбуждается исключение, то есть о проблеме ставится в известность вызывающая программа. Какая-то другая функция в программе должна обработать исключение, то есть как-то отреагировать на него. Материал об исключениях разбит на две части. В главе 11 описан основной синтаксис и приведен простой пример, иллюстрирующий возбуждение и обработку исключений типа класса. Поскольку реальные исключения в программах обычно являются объектами некоторой иерархии классов, то мы вернемся к этому вопросу в главе 19, после того как узнаем, что такое объектно-ориентированное программирование.

В главе 12 представлена обширная коллекция обобщенных алгоритмов стандартной библиотеки и способы их применения к контейнерным типам из главы 6, а также к массивам встроенных типов. Эта глава начинается разбором примера построения программы с использованием обобщенных алгоритмов. Итераторы, введенные в главе 6, обсуждаются более детально в главе 12, поскольку именно они являются связующим звеном между обобщенными алгоритмами и контейнерными типами. Также мы вводим и иллюстрируем на примерах понятие объекта-функции. Объекты-функции позволяют задавать альтернативную семантику операций, используемых в обобщенных алгоритмах, – скажем, операций сравнения на равенство или по величине. Детальное описание самих алгоритмов и примеры их использования приводятся в приложении.

Главы 13-16 (часть IV) посвящены объектному программированию, то есть использованию механизма классов для создания абстрактных типов данных. С помощью типов данных, описывающих конкретную предметную область, язык С++ позволяет программистам сосредоточиться на решении основной задачи и тратить меньше усилий на второстепенные. Фундаментальные для приложения типы данных могут быть реализованы один раз и использованы многократно, что дает программисту возможность не думать о деталях реализации главной задачи. Инкапсуляция данных значительно упрощает последующее сопровождение и модификацию программы.

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

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

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

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

Шаблоны классов – тема главы 16. Шаблон класса можно рассматривать как алгоритм создания экземпляра класса, в котором параметры шаблона подлежат замене на конкретные значения типов или констант. Скажем, в шаблоне класса vector параметризован тип его элементов. В классе для представления некоторого буфера можно параметризовать не только тип размещаемых элементов, но и размер самого буфера. При разработке сложных механизмов, например в области распределенной обработки данных, могут быть параметризованы практически все интерфейсы: межпроцессной коммуникации, адресации, синхронизации. В главе 16 мы расскажем, как определить шаблон класса, как создать экземпляр класса, подставляя в шаблон конкретные значения, как определить члены шаблона класса (функции-члены, статические члены и вложенные типы) и как следует организовывать программу, в которой используются шаблоны классов. Заканчивается эта глава содержательным примером шаблона класса.

Объектно-ориентированному программированию (ООП) и его поддержке в С++ посвящены главы 17-20 (часть IV). В главе 17 описываются средства поддержки базовых концепций ООП – наследования и позднего связывания. В ООП между классами, имеющими общие черты поведения, устанавливаются отношения родитель/потомок (или тип/подтип). Вместо того чтобы повторно реализовывать общие характеристики, класс-потомок может унаследовать их от класса-родителя. В класс-потомок (подтип) следует добавить только те детали, которые отличают его от родителя. Например, мы можем определить родительский класс Employee (работник) и двух его потомков: TemporaryEmpl (временный работник) и Manager (начальник), которые наследуют все поведение Employee. В них самих реализованы только специфичные для подтипа особенности. Второй аспект ООП, полиморфизм, позволяет родительскому классу представлять любого из своих наследников. Скажем, класс Employee может адресовать не только объект своего типа, но и объект типа TemporaryEmpl или Manager. Позднее связывание – это способность разрешения операций во время выполнения, то есть выбора нужной операции в зависимости от реального типа объекта. В С++ это реализуется с помощью механизма виртуальных функций.

Итак, в главе 17 представлены базовые черты ООП. В ней мы продолжим начатую в главе 6 работу над системой текстового поиска – спроектируем и реализуем иерархию классов запросов Query.

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

В главе 19 представлено понятие идентификации типа во время выполнения (RTTI – run time type identification). RTTI позволяет программе запросить у полиморфного объекта класса информацию о его типе во время выполнения. Например, мы можем спросить у объекта Employee, действительно ли он представляет собой объект типа Manager. Кроме того, в главе 19 мы вернемся к исключениям и рассмотрим иерархию классов исключений стандартной библиотеки, приводя примеры построения и использования своей собственной иерархии классов исключений. В этой главе рассматривается также вопрос о разрешении перегруженных функций в случае наследования классов.

В главе 20 подробно рассматривается использование библиотеки ввода/вывода iostream. Здесь мы на примерах покажем основные возможности ввода и вывода, расскажем, как определить свои операторы ввода и вывода для класса, как проверять состояние потока и изменять его, как форматировать данные. Библиотека ввода/вывода представляет собой иерархию классов с множественным и виртуальным наследованием.

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

При написании книги зачастую приходится оставлять в стороне множество вопросов, которые представляются не менее важными, чем вошедшие в книгу. Отдельные аспекты языка – детальное описание того, как работают конструкторы, в каких случаях создаются временные объекты, общие вопросы эффективности – не вписывались во вводный курс. Однако эти аспекты имеют огромное значение при проектировании реальных приложений. Перед тем как взяться за “C++ для начинающих”, Стен написал книгу “Inside the C++ Object Model” [LIPPMAN96a], в которой освещаются именно эти вопросы. В тех местах “C++ для начинающих”, где читателю может потребоваться более детальная информация, даются ссылки на разделы указанной книги.

Некоторые части стандартной библиотеки С++ были сознательно исключены из рассмотрения, в частности поддержка национальных языков и численные методы. Стандартная библиотека С++ очень обширна, и все ее аспекты невозможно осветить в одном учебнике. Материал по отсутствующим вопросам вы можете найти в книгах, приведенных в списке литературы ([MUSSER96] и [STRUOSTRUP97u]). Наверняка вскоре выйдет еще немало книг, освещающих различные аспекты стандартной библиотеки С++.

Изменения в третьем издании

Все изменения можно разбить на четыре основные категории:

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

материал, посвященный стандартной библиотеке С++, в том числе типам complex, string, auto_ptr, pair, последовательным и ассоциативным контейнерам (в основном это list, vector, map и set) и обобщенным алгоритмам;

коррективы в старом тексте, отражающие улучшения, расширения и изменения, которые новый стандарт С++ привнес в существовавшие ранее средства языка. Примером улучшения может служить использование предваряющих объявлений для вложенных типов, ранее отсутствовавшая. В качестве примера изменения можно привести возможность для экземпляра виртуальной функции производного класса возвращать тип, производный от типа значения, возвращаемого экземпляром той же функции из базового класса. Это изменение поддерживает операцию с классами, которую иногда называют клонированием или фабрикацией классов (виртуальная функция clone() иллюстрируется в разделе 17.5.7). Пример расширения языка – возможность явно специализировать один или более параметров-типов для шаблонов функций (на самом деле, весь механизм шаблонов был радикально расширен – настолько, что его можно назвать новым средством языка!);

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

Будущее С++

Во время публикации книги комитет по стандартизации С++ ISO/ANSI закончил техническую работу по подготовке первого международного стандарта С++. Стандарт опубликован Международным комитетом по стандартизации (ISO) летом 1998 года.

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

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

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

Благодарности

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

На разных стадиях работы над рукописью многие люди вносили различные полезные замечания: Пол Эбрахамс (Paul Abrahams), Майкл Болл (Michael Ball), Стивен Эдвардс (Stephen Edwards), Кэй Хорстманн (Cay Horstmann), Брайан Керниган (Brian Kernighan), Том Лайонс (Tom Lyons), Роберт Мюррей (Robert Murray), Эд Шейбель (Ed Scheibel), Рой Тэрнер (Roy Turner), Йон Вада (Jon Wada). Особо нам хочется поблагодарить Майкла Болла за важные комментарии и поддержку. Мы благодарим Кловис Тондо (Clovis Tondo) и Брюса Леюнга (Bruce Leung) за вдумчивую рецензию.

Стен выражает особо теплую благодарность Ши-Чюань Хуань (Shyh-Chyuan Huang) и Джинко Гото (Jinko Gotoh) за их помощь в работе над рассказом о Жар-Птице (Firebird), Иона Ваду и, конечно, Джози.

Джози благодарит Габби Зильберман (Gabby Silbermarr), Карен Беннет (Karen Bennet), а также команду Центра углубленных исследований (Centre for Advanced Studies) за поддержку во время написания книги. И выражает огромную благодарность Стену за привлечение к работе над книгой.

Мы оба хотим поблагодарить замечательный редакторский коллектив за их упорную работу и безграничное терпение: Дебби Лафферти (Debbie Lafferty), которая не оставляла вниманием эту книгу с самого первого издания, Майка Хендриксона (Mike Hendrickson) и Джона Фуллера (John Fuller). Компания Big Purple Company проделала замечательную работу по набору книги. Иллюстрация в разделе 6.1 принадлежит Елене Дрискилл (Elena Driskill). Мы благодарим ее за разрешение перепечатки.

Благодарности во втором издании

Эта книга явилась результатом работы множества остающихся за сценой людей, помогавших автору. Наиболее сердечные благодарности мы приносим Барбаре Му (Barbara Moo). Ее поддержка, советы, внимательное чтение бесчисленных черновиков книги просто неоценимы. Особые благодарности Бьярну Страуструпу за постоянную помощь и поддержку и за прекрасный язык, который он подарил нам, а также Стивену Дьюхерсту (Stephen Dewhurst), который так много помогал мне при освоении С++, и Ненси Уилкинсон (Nancy Wilkinson) – коллеге по работе над cfront.

Дэг Брюк (Dag Bruck), Мартин Кэрролл (Martin Carroll), Уильям Хопкинс (William Hopkins), Брайан Керниган (Brian Kernighan), Эндрю Кениг (Andrew Koenig), Алексис Лейтон (Alexis Layton) и Барбара Му (Barbara Moo) помогали нам особо ценными замечаниями. Их рецензии значительно улучшили качество книги. Энди Бейли (Andy Baily), Фил Браун (Phil Brown), Джеймс Коплиен (James Coplien), Элизабет Флэнаган (Elizabeth Flanagan), Дэвид Джордан (David Jordan), Дон Кретч (Don Kretsch), Крейг Рубин (Craig Rubin), Джонатан Шопиро (Jonathan Shopiro), Джуди Уорд (Judy Ward), Ненси Уилкинсон (Nancy Wilkinson) и Клей Уилсон (Clay Wilson) просмотрели множество черновиков книги и дали много полезных комментариев. Дэвид Проссер (David Prosser) прояснил множество вопросов, касающихся ANSI C.

Джерри Шварц (Jerry Schwarz), автор библиотеки iostream, обеспечил нас оригинальной документацией, которая легла в основу Приложения А (глава 20 в третьем издании). Мы высоко оцениваем его замечания к этому Приложению. Мы благодарим всех остальных членов команды, работавшей на версией 3.0: Лауру Ивс (Laura Eaves), Джорджа Логотетиса (George Logothetis), Джуди Уорд (Judy Ward) и Ненси Уилкинсон (Nancy Wilkinson).

Джеймс Эдкок (James Adcock), Стивен Белловин (Steven Bellovin), Йон Форрест (Jon Forrest), Морис Эрлих (Maurice Herlihy), Норман Керт (Norman Kerth), Даррелл Лонг (Darrell Long), Виктор Миленкович (Victor Milenkovic) и Джастин Смит (Justin Smith) рецензировали книгу для издательства Addison-Wesley.

Дэвид Беккердорф (David Beckedorff), Дэг Брюк (Dag Bruck), Джон Элбридж (John Eldridge), Джим Хьюмелсин (Jim Humelsine), Дэйв Джордан (Dave Jordan), Эми Клейнман (Ami Kleinman), Эндрю Кениг (Andrew Koenig), Тим О'Конски (Tim O'Konski), Кловис Тондо (Clovis Tondo) и Стив Виноски (Steve Vinoski) указали на ошибки в первом издании.

Я выражаю глубокую благодарность Брайану Кернигану (Brian Kernighan) и Эндрю Кенигу (Andrew Koenig) за программные средства для типографского набора текста.

Список литературы

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

[BOOCH94] Booch, Grady, Object-Oriented Analysis and Design, Benjamin/Cummings. Redwood City, CA (1994) ISBN 0-8053-5340-2.

[GAMMA95] Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides, Design Patterns, Addison Wesley Longman, Inc., Reading, MA (1995) ISBN 0-201-63361-2.

[GHEZZI97] Ghezzi, Carlo, and Mehdi Jazayeri, Programming Language Concepts, 3rd Edition, John Wiley and Sons, New York, NY (1997) ISBN 0-471-10426-4.

[HARBISON88] Samuel P. Harbison and Guy L. Steele, Jr., C: A Reference Manual, 3rd Edition, Prentice-Hall, Englewood Cliffs, NJ (1988) ISBN 0-13-110933-2.

[ISO-C++97] Draft Proposed International Standard for Information Systems — Programming Language C++ – Final Draft (FDIS) 14882.

[KERNIGHAN88] Kernighan, Brian W.I. and Dennis M. Ritchie, The C Programming Language, Prentice-Hall, Englewood Cliffs, NJ (1988) ISBN 0-13-110362-8.

[KOENIG97] Koenig, Andrew, and Barbara Moo, Ruminations on C++, Addison Wesley Longman, Inc., Reading, MA (1997) ISBN 0-201-42339-1.

[LIPPMAN91] Lippman, Stanley, C++ Primer, 2nd Edition, Addison Wesley Longman, Inc., Reading, MA (1991) ISBN 0-201-54848-8.

[LIPPMAN96a] Lippman, Stanley, Inside the C++ Object Model, Addison Wesley Longman, Inc., Reading, MA (1996) ISBN 0-201-83454-5.

[LIPPMAN96b] Lippman, Stanley, Editor, C++ Gems, a SIGS Books imprint, Cambridge University Press, Cambridge, England (1996) ISBN 0-13570581-9.

[MEYERS98] Movers, Scott, Effective C++, 2nd Edition, Addison Wesley Longman, Inc., Reading, MA (1998) ISBN 0-201-92488-9.

[MEYERS96] Meyers, Scott, More Effective C++, Addison Wesley Longman, Inc., Reading, MA (1996) ISBN 0-201-63371-X.

[MURRAY93] Murray Robert B., C++ Strategies and Tactics, Addison Wesley Longman, Inc., Reading, MA (1993) ISBN 0-201-56382-7.

[MUSSER96] Musser, David R., and Atui Saint, STL Tutorial and Reference Guide, Addison Wesley Longman, Inc., Reading, MA (1996) ISBN 0-201-63398-1.

[NACKMAN94] Barton, John J., and Lee R. Nackman, Scientific and Engineering C++, An Introduction with Advanced Techniques and Examples, Addison Wesley Longman, Inc., Reading, MA (1994) ISBN 0-201-53393-6.

[NEIDER93] Neider, Jackie, Tom Davis, and Mason Woo, OpenGL Programming Guide, Addison Wesley Inc., Reading, MA (1993) ISBN 0-201-63274-8.

[PERSON68] Person, Russell V., Essentials of Mathematics, 2nd Edition, John Wiley & Sons, Inc., New York, NY (1968) ISBN 0-132-84191-6.

[PLAUGER92] Plauger, P.J., The Standard C Library, Prentice-Hall, Englewood Cliffs, NJ (1992) ISBN 0-13-131509-9.

[SEDGEWICK88] Sedgewick, Robert, Algorithms, 2nd Edition, Addison Wesley Longman, Inc., Reading, MA (1988) ISBN 0-201-06673-4.

[SHAMPINE97] Shampine, L.E, R.C. Alien, Jr., and S. Pruess, Fundamentals of Numerical Computing, John Wiley & Sons, Inc., New York, NY (1997) ISBN 0-471-16363-5.

[STROUSTRUP94] Stroustrup, Bjarne, The Design and Evolution of C++, Addison Wesley Longman, Inc., Reading, MA (1994) ISBN 0-201-54330-3.

[STROUSTRUP97] Stroustrup, Bjarne, The C++ Programming Language, 3rd Edition, Addison Wesley Longman, Inc., Reading, MA (1997) ISBN 0-201-88954-4.

[UPSTILL90] Upstill, Steve, The RenderMan Companion, Addison Wesley Longman, Inc., Reading, MA (1990) ISBN 0-201-50868-0.

[WERNECKE94] Wernecke, Josie, The Inventor Mentor, Addison Wesley Longman, Inc., Reading, MA (1994) ISBN 0-201-62495-8.

[YOUNG95] Young, Douglas A., Object-Oriented Programming with C++ and OSF/ Motif, 2nd Edition, Prentice-Hall, Englewood Cliffs, NJ (1995) ISBN 0-132-09255-7.


Часть I

Краткий обзор языка C++

Программы, которые мы пишем, имеют два основных аспекта:

набор алгоритмов;

набор данных, которыми оперируют.

Эти два аспекта оставались неизменными за всю недолгую историю программирования, зато отношения между ними (парадигма программирования) менялись. .

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

В 70-е годы процедурную парадигму стала вытеснять парадигма абстрактных типов данных (теперь чаще называемая объектным подходом). В рамках этой парадигмы задача моделируется набором абстракций данных. В С++ эти абстракции получили название классов. Наша библиотечная система могла бы быть представлена как взаимоотношения объектов различных классов, представляющих книги, читателей, даты возврата и т.п. Алгоритмы, реализуемые каждым классом, называются открытым интерфейсом класса. Данные “скрыты” внутри объектов класса. Парадигму абстрактных типов данных поддерживают такие языки, как CLU, Ada и Modula-2. В части IV обсуждаются вопросы поддержки этой парадигмы языком С++.

Объектно-ориентированное программирование расширяет парадигму абстрактных типов данных механизмом наследования (повторного использования существующих объектов) и динамического связывания (повторного использования существующих интерфейсов). Вводятся отношения тип-подтип. Книга, видеокассета, компакт-диск – все они хранятся в библиотеке, и поэтому могут быть названы подтипами (или подклассами) одного родительского типа, представляющего то, что может храниться в библиотеке. Хотя каждый из классов способен реализовывать свой собственный алгоритм выдачи и возврата, открытый интерфейс для них одинаков. Три наиболее известных языка, поддерживающие объектно-ориентированный подход, – это Simula, Smalltalk и Java. В части V рассматриваются вопросы поддержки парадигмы объектно-ориентированного программирования в С++.

Хотя мы и считаем С++ в основном объектно-ориентированным языком, он поддерживает и процедурную, и объектную парадигму. Преимущество такого подхода в том, что для каждого конкретного случая можно выбрать наилучшее решение. Однако есть и обратная сторона медали: С++ является достаточно громоздким и сложным языком.

В части I мы “пробежимся” по всем основным аспектам С++. Одна из причин такого краткого обзора – желание дать читателю представление об основных возможностях языка, чтобы затем приводить достаточно содержательные примеры. Скажем, мы не будем рассматривать в деталях понятие класса вплоть до главы 13, однако без упоминания о нем наши примеры оказались бы неинтересными и надуманными.

Другая причина такого поверхностного, но широкого обзора – эстетическая. Если вы еще не оценили красоту и сложность сонаты Бетховена или живость регтайма Джоплина, вам будет безумно скучно разбираться в отдельных деталях вроде диезов, бемолей, октав и аккордов. Однако, не овладев ими, вы не научитесь музыке. Во многом это справедливо и для программирования. Разбираться в путанице приоритетов операций или правил приведения типов скучно, но совершенно необходимо для овладения С++.

В главе 1 представлены базовые элементы языка: встроенные типы данных, переменные, выражения, инструкции (statements) и функции. Мы увидим минимальную законченную С++ программу, обсудим вопросы компиляции, коснемся препроцессора и поддержки ввода/вывода.

В главе 2 мы реализуем абстракцию массива – процедурно, объектно, и объектно-ориентированно. Мы сравним нашу реализацию с реализацией, предоставляемой стандартной библиотекой С++, и познакомимся с набором обобщенных алгоритмов стандартной библиотеки. Мы коснемся и таких вещей, как шаблоны, исключения и пространства имен. Фактически, мы представим все особенности языка С++, хотя обсуждение деталей отложим до следующих глав.

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

1. Начинаем

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

1.1. Решение задачи

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

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

Прочитать файл с записями о продажах.

Подсчитать количество продаж по названиям и по издателям.

Отсортировать записи по издателям.

Вывести результаты.

Решения для подзадач 1, 2 и 4 известны, их не нужно делить на более мелкие подзадачи. А вот третья подзадача все еще слишком сложна. Будем дробить ее дальше.

3a.  Отсортировать записи по издателям.

3b.  Для каждого издателя отсортировать записи по названиям.

3c.  Сравнить соседние записи в группе каждого издателя. Для каждой одинаковой пары увеличить счетчик для первой записи и удалить вторую.

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

Прочитать файл с записями о продажах.

Отсортировать этот файл: сначала по издателям, внутри каждого издателя – по названиям.

Удалить повторяющиеся названия, наращивая счетчик.

Вывести результат в новый файл.

Результирующая последовательность действий называется алгоритмом. Следующий шаг – перевести наш алгоритм на некоторый язык программирования, в нашем случае – на С++.

1.2. Программа на языке C++

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

int book_count = 0;

book_count = books_on_shelf + books_on_order;

cout << "значение переменной book_count: " << book_count;

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

Вторая инструкция – присваивание. Она помещает в область памяти, отведенную переменной book_count, результат сложения двух других переменных –  books_on_shelf и books_on_order. Предполагается, что эти две целочисленные переменные определены где-то ранее в программе и им присвоены некоторые значения.

Третья инструкция является инструкцией вывода. cout – это выходной поток, направленный на терминал, << – оператор вывода. Эта инструкция выводит в cout – то есть на терминал – сначала символьную константу, заключенную в двойные кавычки ("значение переменной book_count: "), затем значение, содержащееся в области памяти, отведенном под переменную book_count. В результате выполнения данной инструкции мы получим на терминале сообщение:

çíà÷åíèå ïåðåìåííîé book_count: 11273

если значение book_count равно 11273 в данной точке выполнения программы.

Инструкции часто объединяются в именованные группы, называемые функциями. Так, группа инструкций, необходимых для чтения исходного файла, объединена в функцию readIn(). Аналогичным образом инструкции для выполнения оставшихся подзадач сгруппированы в функции sort(), compact() и print().

В каждой С++ программе должна быть ровно одна функция с именем main(). Вот как может выглядеть эта функция для нашего алгоритма:

int main()

{

 readIn();

 sort();

 compact();

 print();

 return 0;

}

Исполнение программы начинается с выполнения первой инструкции функции main(), в нашем случае – вызовом функции readIn(). Затем одна за другой исполняются все дальнейшие инструкции, и, выполнив последнюю инструкцию функции main(), программа заканчивает работу.

Функция состоит их четырех частей: типа возвращаемого значения, имени, списка параметров и тела функции. Первые три части составляют прототип функции.

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

В нашем примере тело функции main() содержит вызовы функций readIn(), sort(), compact() и print(). Последней выполняется инструкция

return 0;

Инструкция return обеспечивает механизм завершения работы функции. Если оператор return сопровождается некоторым значением (в данном примере 0), это значение становится возвращаемым значением функции. В нашем примере возвращаемое значение 0 говорит об успешном выполнении функции main(). (Стандарт С++ предусматривает, что функция main() возвращает 0 по умолчанию, если оператор return не использован явно.)

Давайте закончим нашу программу, чтобы ее можно было откомпилировать и выполнить.  Во-первых, мы должны определить функции readIn(), sort(), compact() и print(). Для начала вполне подойдут заглушки:

void readIn() { cout << "readIn()\n"; }

void sort() { cout << "sort()\n"; }

void compact() { cout << "compact()\n"; }

void print() { cout << "print ()\n"; }

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

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

Имя файла с текстом программы, или исходного файла, как правило, состоит из двух частей: собственно имени (например, bookstore) и расширения, записываемого после точки. Расширение, в соответствии с принятыми соглашениями, служит для определения назначения файла. Файл bookstore.h является заголовочным файлом для С или С++ программы. (Необходимо отметить, что стандартные заголовочные файлы С++ являются исключением из правила: у них нет расширения.)

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

В других операционных системах, в частности в DOS, где строчные и прописные буквы не различаются, разные реализации могут использовать разные соглашения для обозначения исходных файлов С++. Чаще всего употребляются расширения .cpp и .cxx: bookstore.cpp, bookstore.cxx.

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

Итак, создадим текст законченной С++ программы (используя любой текстовый редактор):

#include <iostream>

using namespace std;

void readIn() { cout << "readIn()\n"; }

void sort() { cout << "sort()\n"; }

void compact() { cout << "compact()\n"; }

void print() { cout << "print ()\n"; }

int main()

{

 readIn();

 sort();

 compact();

 print();

 return 0;

}

Здесь iostream – стандартный заголовочный файл библиотеки ввода/вывода (обратите внимание: у него нет расширения). Эта библиотека содержит информацию о потоке cout, используемом в нашей программе. #include является директивой препроцессора, заставляющей включить в нашу программу текст из заголовочного файла iostream. (Директивы препроцессора рассматриваются в разделе 1.3.)

Непосредственно за директивой препроцессора

#include <iostream>

следует инструкция

using namespace std;

Эта инструкция называется директивой using. Имена, используемые в стандартной библиотеке С++ (такие, как cout), объявлены в пространстве имен std и невидимы в нашей программе до тех пор, пока мы явно не сделаем их видимыми, для чего и применяется данная директива. (Подробнее о пространстве имен говорится в разделах 2.7 и 8.5.)1

После того как исходный текст программы помещен в файл, скажем prog1.C, мы должны откомпилировать его. В UNIX для этого выполняется следующая команда:

$ CC prog1.C

Здесь $ представляет собой приглашение командной строки. CC – команда вызова компилятора С++, принятая в большинстве UNIX-систем. Команды вызова компилятора могут быть разными в разных системах.

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

синтаксические ошибки. Программист может допустить “грамматические”, с точки зрения языка С++, ошибки. Например:

int main( { // ошибка – пропущена ')'

 readIn(): // ошибка – недопустимый символ ':'

 sort();

 compact();

 print();

 return 0  // ошибка – пропущен символ ';'

}

ошибки типизации. С каждой переменной и константой в С++ сопоставлен некоторый тип. Например, число 10 – целого типа. Строка "hello", заключенная в двойные кавычки, имеет символьный тип. Если функция ожидает получить в качестве параметра целое значение, а получает символьную строку, компилятор рассматривает это как ошибку типизации.

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

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

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

readIn()

sort()

compact()

print()

В С++ набор основных типов данных – это целый и вещественный числовые типы, символьный тип и логический, или булевский. Каждый тип обозначается своим ключевым словом. Любой объект программы ассоциируется с некоторым типом. Например:

int    age = 10;

double price = 19.99;

char   delimiter = ' ';

bool   found = false;

Здесь определены четыре объекта: age, price, delimiter, found, имеющие соответственно типы целый, вещественный с двойной точностью, символьный и логический. Каждый объект инициализирован константой – целым числом 10, вещественным числом 19.99, символом пробела и логическим значением false.

Между основными типами данных может осуществляться неявное преобразование типов. Если переменной age, имеющей тип int, присвоить константу типа double, например:

age = 33.333;

то значением переменной age станет целое число 33. (Стандартные преобразования типов, а также общие проблемы преобразования типов рассматриваются в разделе 4.14.)

Стандартная библиотека С++ расширяет базовый набор типов, добавляя к ним такие типы, как строка, комплексное число, вектор, список. Примеры:

// заголовочный файл с определением типа string

#include <string>

string current_chapter = "Начинаем";

// заголовочный файл с определением типа vector

#include <vector>

vector<string> chapter_titles(20);

Здесь current_chapter – объект типа string, инициализированный константой "Íà÷èíàåì". Переменная chapter_titles – вектор из 20 элементов строкового типа. Несколько необычный синтаксис выражения

vector<string>

сообщает компилятору о необходимости создать вектор, содержащий объекты типа string. Для того чтобы определить вектор из 20 целых значений, необходимо написать:

vector<int> ivec(20);

Никакой язык, никакие стандартные библиотеки не способны обеспечить нас всеми типами данных, которые могут потребоваться. Взамен современные языки программирования предоставляют механизм создания новых типов данных. В С++ для этого служит механизм классов. Все расширенные типы данных из стандартной библиотеки С++, такие как строка, комплексное число, вектор, список, являются классами, написанными на С++. Классами являются и объекты из библиотеки ввода/вывода.

Механизм классов – одна из самых главных особенностей языка С++, и в главе 2 мы рассмотрим его очень подробно.

1.2.1. Порядок выполнения инструкций

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

int main()

{

 readIn();

 sort();

 compact();

 print();

 return 0;

}

первой будет выполнена инструкция readIn(), за ней sort(), compact() и наконец print().

Однако представим себе ситуацию, когда количество продаж невелико: оно равно 1 или даже 0. Вряд ли стоит вызывать функции sort() и compact() для такого случая. Но вывести результат все-таки нужно, поэтому функцию print() следует вызывать в любом случае. Для этого случая мы можем использовать условную инструкцию if. Нам придется переписать функцию readIn() так, чтобы она возвращала количество прочитанных записей:

// readIn() âîçâðàùàåò êîëè÷åñòâî ïðî÷èòàííûõ çàïèñåé

// âîçâðàùàåìîå çíà÷åíèå èìååò òèï int

int readIn() { ... }

// ...

int main()

{

 int count = readIn();

 // åñëè êîëè÷åñòâî çàïèñåé áîëüøå 1,

 // òî âûçâàòü sort() è compact()

 if ( count > 1 ) {

   sort();

   compact();

 }

 if ( count == 0 )

   cout << "Ïðîäàæ íå áûëî\n";

 else

   print();

 return 0;

}

Первая инструкция if обеспечивает условное выполнение блока программы: функции sort() и compact() вызываются только в том случае, если count больше 1. Согласно второй инструкции if на терминал выводится сообщение “Продаж не было”, если условие истинно, т.е. значение count равно 0. Если же это условие ложно, производится вызов функции print(). (Детальное описание инструкции if приводится в разделе 5.3.)

Другим распространенным способом непоследовательного выполнения программы является итерация, или инструкция цикла. Такая инструкция предписывает повторять блок программы до тех пор, пока некоторое условие не изменится с true на false. Например:

int main()

{

 int iterations = 0;

 bool continue_loop = true;

 while ( continue_loop != false )

 {

   iterations++;

   cout << "Öèêë áûë âûïîëíåí " << iterations << "ðàç\n";

   if ( iterations == 5 )

     continue_loop = false;

 }

 return 0;

}

В этом надуманном примере цикл while выполняется пять раз, до тех пор пока переменная iterations не получит значение 5 и переменная continue_loop не станет равной false. Инструкция

iterations++;

увеличивает значение переменной iterations на единицу. (Инструкции цикла детально рассматриваются в главе 5.)

1.3. Директивы препроцессора

Заголовочные файлы включаются в текст программы с помощью директивы препроцессора #include. Директивы препроцессора начинаются со знака “диез” (#), который должен быть самым первым символом строки. Программа, которая обрабатывает эти директивы, называется препроцессором (в современных компиляторах препроцессор обычно является частью самого компилятора).

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

#include <some_file.h>

#include "my_file.h"

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

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

#ifndef BOOKSTORE_H

#define BOOKSTORE_H

 /* содержимое файла bookstore.h */

#endif

Условная директива #ifndef проверяет, не было ли значение BOOKSTORE_H определено ранее. (BOOKSTORE_H – это константа препроцессора; такие константы принято писать заглавными буквами.) Препроцессор обрабатывает следующие строки вплоть до директивы #endif. В противном случае он пропускает строки от #ifndef до # endif.

Директива

#define BOOKSTORE_H

определяет константу препроцессора BOOKSTORE_H. Поместив эту директиву непосредственно после директивы #ifndef, мы можем гарантировать, что содержательная часть заголовочного файла bookstore.h будет включена в исходный текст только один раз, сколько бы раз ни включался в текст сам этот файл.

Другим распространенным примером применения условных директив препроцессора является включение в текст программы отладочной информации. Например:

int main()

{

#ifdef DEBUG

 cout << "Íà÷àëî âûïîëíåíèÿ main()\n";

#endif

 string word;

 vector<string> text;

 while ( cin >> word )

 {

#ifdef DEBUG

   cout << "Ïðî÷èòàíî ñëîâî: " << word << "\n";

#endif

   text.push_back(word);

 }

 // ...

}

Если константа DEBUG не определена, результирующий текст программы будет выглядеть так:

int main()

{

 string word;

 vector<string> text;

 while ( cin >> word )

 {

   text.push_back(word);

 }

 // ...

}

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

int main()

{

 cout << "Íà÷àëî âûïîëíåíèÿ main()\n";

 string word;

 vector<string> text;

 while ( cin >> word )

 {

   cout << "Ïðî÷èòàíî ñëîâî: " << word << "\n";

   text.push_back(word);

 }

 // ...

}

Константа препроцессора может быть определена в командной строке при вызове компилятора с помощью опции -D (в различных реализациях эта опция может называться по-разному). Для UNIX-систем вызов компилятора с определением препроцессорной константы DEBUG выглядит следующим образом:

$ CC -DDEBUG main.C

Есть константы, которые автоматически определяются компилятором. Например, мы можем узнать, компилируем ли мы С++ или С программу. Для С++ программы автоматически определяется константа __cplusplus (два подчеркивания). Для стандартного С определяется __STDC__. Естественно, обе константы не могут быть определены одновременно. Пример:

#idfef __cplusplus

 // компиляция С++ программы

 extern "C";

 // extern "C" объясняется в главе 7

#endif

int main(int,int);

Другими полезными предопределенными константами (в данном случае лучше сказать переменными) препроцессора являются __LINE__ и __FILE__. Переменная __LINE__ содержит номер текущей компилируемой строки, а __FILE__ – имя компилируемого файла. Вот пример их использования:

if ( element_count == 0 )

 cerr << "Ошибка. Файл: " << __FILE__

      << " Строка: " << __LINE__

      << "element_count не может быть 0";

Две константы __DATE__ и __TIME__ содержат дату и время компиляции.

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

#include <assert.h>

assert.h – это заголовочный файл стандартной библиотеки С. Программа на C++ может ссылаться на заголовочный файл как по его имени, принятому в C, так и по имени, принятому в C++. В стандартной библиотеке С++ этот файл носит имя cassert. Имя заголовочного файла в библиотеке С++ отличается от имени соответствующего файла для С отсутствием расширения .h и подставленной спереди буквой c (выше уже упоминалось, что в заголовочных файлах для C++ расширения не употребляются, поскольку они могут зависеть от реализации).

Эффект от использования директивы препроцессора #include зависит от типа заголовочного файла. Инструкция

#include <cassert>

включает в текст программы содержимое файла cassert. Но поскольку все имена, используемые в стандартной библиотеке С++, определены в пространстве std, имя assert() будет невидимо до тех пор, пока мы явно не сделаем его видимым с помощью следующей using-директивы:

using namespace std;

Если же мы включаем в программу заголовочный файл для библиотеки С

#include <assert.h>

то надобность в using-директиве отпадает: имя assert() будет видно и так2. (Пространства имен используются разработчиками библиотек для предотвращения засорения глобального пространства имен. В разделе 8.5 эта тема рассматривается более подробно.)

1.4. Немного о комментариях

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

В С++ есть два типа комментариев. Один – такой же, как и в С, использующий символы /* для обозначения начала и */ для обозначения конца комментария. Между этими парами символов может находиться любой текст, занимающий одну или несколько строк: вся последовательность между /* и */ считается комментарием. Например:

/*

* Это первое знакомство с определением класса в C++.

* Классы используются как в объектном, так и в

* объектно-ориентированном программировании. Реализация

* класса Screen представлена в главе 13.

*/

class Screen {

   /* Это называется телом класса */

public:

   void home();    /* переместить курсор в позицию 0,0 */

   void refresh ();/* перерисовать экран               */

private:

   /* Классы поддерживают "сокрытие информации"    */

   /* Сокрытие информации ограничивает доступ из   */

   /* программы к внутреннему представлению класса */

   /* (его данным). Для этого используется метка   */

   /* "private:"                                   */

   int height, width;

}

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

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

#include <iostream>

/* комментарии /* */ не могут быть вложенными.

* Строку "не вкладываются" компилятор рассматривает,

* как часть программы. Это же относится к данной и следующей строкам

*/

int main() {

   cout << "Здравствуй, мир\n";

}

Один из способов решить проблему вложенных комментариев – поставить пробел между звездочкой и косой чертой:

/* * /

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

Второй тип комментариев – однострочный. Он начинается последовательностью символов // и ограничен концом строки. Часть строки вправо от двух косых черт игнорируется компилятором. Вот пример нашего класса Screen с использованием двух строчных комментариев:

/*

* Первое знакомство с определением класса в C++.

* Классы используются как в объектном, так и в

* объектно-ориентированном программировании. Реализация

* класса Screen представлена в главе 13.

*/

class Screen {

   // Это называется телом класса

public:

   void home();     // переместить курсор в позицию 0,0

   void refresh (); // перерисовать экран

private:

   /* Классы поддерживают "сокрытие информации".    */

   /* Сокрытие информации ограничивает доступ из   */

   /* программы к внутреннему представлению класса */

   /* (его данным). Для этого используется метка   */

   /* "private:"                                   */

   int height, width;

}

Обычно в программе употребляют сразу оба типа комментариев. Строчные комментарии удобны для кратких пояснений – в одну или полстроки, а комментарии, ограниченные /* и */, лучше подходят для развернутых многострочных пояснений.

1.5. Первый взгляд на ввод/вывод

Частью стандартной библиотеки С++ является библиотека iostream, которая реализована как иерархия классов и обеспечивает базовые возможности ввода/вывода.

Ввод с терминала, называемый стандартным вводом, “привязан” к предопределенному объекту cin. Вывод на терминал, или стандартный вывод, привязан к объекту cout. Третий предопределенный объект, cerr, представляет собой стандартный вывод для ошибок. Обычно он используется для вывода сообщений об ошибках и предупреждений.

Для использования библиотеки ввода/вывода необходимо включить соответствующий заголовочный файл:

#include <iostream>

Чтобы значение поступило в стандартный вывод или в стандартный вывод для ошибок используется оператор <<:

int v1, v2;

// ...

cout << "ñóììà v1 è v2 = ";

cout << v1 + v2;

cout << "\n";

Последовательность "\n" представляет собой символ перехода на новую строку. Вместо "\n" мы можем использовать предопределенный манипулятор endl.

cout << endl;

Манипулятор endl не просто выводит данные (символ перехода на новую строку), но и производит сброс буфера вывода. (Предопределенные манипуляторы рассматриваются в главе 20.)

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

cout << "сумма v1 и v2 = " << v1 + v2 << "\n";

Для чтения значения из стандартного ввода применяется оператор ввода (>>):

string file_name;

// ...

cout << "Ââåäèòå èìÿ ôàéëà: ";

cin >> file_name;

Операторы ввода, как и операторы вывода, можно сцеплять:

string ifile, ofile;

// ...

cout << "Ââåäèòå èìÿ âõîäíîãî è âûõîäíîãî ôàéëîâ: ";

cin >> ifile >> ofile;

Каким образом ввести заранее неизвестное число значений? Мы вернемся к этому вопросу в конце раздела 2.2, а пока скажем, что последовательность инструкций

string word;

while ( cin >> word )

 // ...

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

( cin >> word )

возвращает false, когда достигнут конец файла. (Подробнее об этом – в главе 20.) Вот пример простой законченной программы, считывающей по одному слову из cin и выводящей их в cout:

#include <iostream>

#include <string>

int main ()

{

 string word;

 while ( cin >> word )

   cout << "Ïðî÷èòàíî ñëîâî: " << word << "\n";

 cout << "Âñå ñëîâà ïðî÷èòàíû!";

}

Вот первое предложение из произведения Джеймса Джойса “Пробуждение Финнегана”:

riverrun, past Eve and Adam's

Если запустить приведенную выше программу и набрать с клавиатуры данное предложение, мы увидим на экране терминала следующее:

Ïðî÷èòàíî ñëîâî: riverrun,

Ïðî÷èòàíî ñëîâî: past

Ïðî÷èòàíî ñëîâî: Eve,

Ïðî÷èòàíî ñëîâî: and

Ïðî÷èòàíî ñëîâî: Adam's

Âñå ñëîâà ïðî÷èòàíû!

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

1.5.1. Файловый ввод/вывод

Библиотека iostream поддерживает и файловый ввод/вывод. Все операции, применимые в стандартному вводу и выводу, могут быть также применены к файлам. Чтобы использовать файл для ввода или вывода, мы должны включить еще один заголовочный файл:

#include <fstream>

Перед тем как открыть файл для вывода, необходимо объявить объект типа ofstream:

ofstream outfile("name-of-file");

Проверить, удалось ли нам открыть файл, можно следующим образом:

if ( ! outfile ) // false, если файл не открыт

  cerr << "Ошибка открытия файла.\n"

Так же открывается файл и для ввода, только он имеет тип ifstream:

ifstream infile("name-of-file");

if ( ! infile ) // false, если файл не открыт

  cerr << "Ошибка открытия файла.\n"

Ниже приводится текст простой программы, которая читает файл с именем in_file и выводит все прочитанные из этого файла слова, разделяя их пробелом, в другой файл, названный out_file.

#include <iostream>

#include <fstream>

#include <string>

int main()

{

 ifstream infile("in_file");

 ofstream outfile("out_file");

 if ( ! infile ) {

   cerr << "Ошибка открытия входного файла.\n"

   return -1;

 }

 if ( ! outfile ) {

   cerr << "Ошибка открытия выходного файла.\n"

   return -2;

 }

 string word;

 while ( infile >> word )

   outfile << word << ' ';

 return 0;

}

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


2. Краткий обзор С++

Эту главу мы начнем с рассмотрения встроенного в язык С++ типа данных “массив”. Массив – это набор данных одного типа, например массив целых чисел или массив строк. Мы рассмотрим недостатки, присущие встроенному массиву, и напишем для его представления свой класс Array, где попытаемся избавиться от этих недостатков. Затем мы построим целую иерархию подклассов, основываясь на нашем базовом классе Array. В конце концов мы сравним наш класс Array с классом vector из стандартной библиотеки С++, реализующим аналогичную функциональность. В процессе создания этих классов мы коснемся таких свойств С++, как шаблоны, пространства имен и обработка ошибок.

2.1. Встроенный тип данных “массив

Как было показано в главе 1, С++ предоставляет встроенную поддержку для основных типов данных – целых и вещественных чисел, логических значений и символов:

// объявление целого объекта ival

// ival инициализируется значением 1024

int ival = 1024;

// объявление вещественного объекта двойной точности dval

// dval инициализируется значением 3.14159

double dval = 3.14159;

// объявление вещественного объекта одинарной точности fval

// fval инициализируется значением 3.14159

float fval = 3.14159;

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

int ival2 = ival1 + 4096;   // сложение

int ival3 = ival2 - ival;   // вычитание

dval = fval * ival;         // умножение

ival = ival3 / 2;           // деление

bool result = ival2 == ival3;   // сравнение на равенство

result = ival2 + ival != ival3; // сравнение на неравенство

result = fval + ival2 < dval;   // сравнение на меньше

result = ival > ival2;          // сравнение на больше

В дополнение к встроенным типам стандартная библиотека С++ предоставляет поддержку для расширенного набора типов, таких, как строка и комплексное число. (Мы отложим рассмотрение класса vector из стандартной библиотеки до раздела 2.7.)

Промежуточное положение между встроенными типами данных и типами данных из стандартной библиотеки занимают составные типы – массивы и указатели. (Указатели рассмотрены в разделе 2.2.)

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

0 1 1 2 3 5 8 13 21

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

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

int fibon[9] = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };

Здесь fibon – это имя массива. Элементы массива имеют тип int, размер (длина) массива равна 9. Значение первого элемента – 0, последнего – 21. Для работы с массивом мы индексируем (нумеруем) его элементы, а доступ к ним осуществляется с помощью операции взятия индекса. Казалось бы, для обращения к первому элементу массива естественно написать:

int first_elem = fibon[1];

Однако это не совсем правильно: в С++ (как и в С) индексация массивов начинается с 0, поэтому элемент с индексом 1 на самом деле является вторым элементом массива, а индекс первого равен 0.Таким образом, чтобы обратиться к последнему элементу массива, мы должны вычесть единицу из размера массива:

fibon[0]; // первый элемент

fibon[1]; // второй элемент

...

fibon[8]; // последний элемент

fibon[9]; // ... ошибка

Девять элементов массива fibon имеют индексы от 0 до 8. Употребление вместо этого индексов 1-9 является одной из самых распространенных ошибок начинающих программистов на С++.

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

int main()

{

 int ia[10];

 int index;

 for (index=0; index<10; ++index)

   // ia[0] = 0, ia[1] = 1 и т.д.

   ia[index] = index;

 for (index=9; index>=0; --index)

   cout << ia[index] << " ";

 cout << endl;

}

Оба цикла выполняются по 10 раз. Все управление циклом for осуществляется инструкциями в круглых скобках за ключевым словом for. Первая присваивает начальное значение переменной index. Это производится один раз перед началом цикла:

index = 0;

Вторая инструкция:

index < 10;

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

ia[index] = index;

Третья управляющая инструкция цикла

++index

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

index = index + 1

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

Вторая инструкция for в нашем примере печатает элементы массива. Она отличается от первой только тем, что в ней переменная index уменьшается от 9 до 0. (Подробнее инструкция for рассматривается в главе 5.)

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

int array0[10]; array1[10];

...

array0 = array1; // îøèáêà

Âìåñòî ýòîãî ìû äîëæíû ïðîãðàììèðîâàòü òàêóþ îïåðàöèþ ñ ïîìîùüþ öèêëà:

for (int index=0; index<10; ++index)

 array0[index] = array1[index];

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

Упражнение 2.1

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

Упражнение 2.2

Какие операции должен поддерживать “полноценный” массив? 

2.2. Динамическое выделение памяти и указатели

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

В С++ объекты могут быть размещены либо статически – во время компиляции, либо динамически – во время выполнения программы, путем вызова функций из стандартной библиотеки. Основная разница в использовании этих методов – в их эффективности и гибкости. Статическое размещение более эффективно, так как выделение памяти происходит до выполнения программы, однако оно гораздо менее гибко, потому что мы должны заранее знать тип и размер размещаемого объекта. К примеру, совсем не просто разместить содержимое некоторого текстового файла в статическом массиве строк: нам нужно заранее знать его размер. Задачи, в которых нужно хранить и обрабатывать заранее неизвестное число элементов, обычно требуют динамического выделения памяти.

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

int ival = 1024;

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

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

int ival2 = ival + 1;

то обращаемся к значению, содержащемуся в переменной ival: прибавляем к нему 1 и инициализируем переменную ival2 этим новым значением, 1025. Каким же образом обратиться к адресу, по которому размещена переменная?

С++ имеет встроенный тип “указатель”, который используется для хранения адресов объектов. Чтобы объявить указатель, содержащий адрес переменной ival, мы должны написать:

int *pint; // указатель на объект типа int

Существует также специальная операция взятия адреса, обозначаемая символом &. Ее результатом является адрес объекта. Следующий оператор присваивает указателю pint адрес переменной ival:

int *pint;

pint = &ival; // pint получает значение адреса ival

Мы можем обратиться к тому объекту, адрес которого содержит pint (ival в нашем случае), используя операцию разыменования, называемую также косвенной адресацией. Эта операция обозначается символом *. Вот как можно косвенно прибавить единицу к ival, используя ее адрес:

*pint = *pint + 1; // неявно увеличивает ival

Это выражение производит в точности те же действия, что и

ival = ival + 1; // явно увеличивает ival

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

Основные отличия между статическим и динамическим выделением памяти таковы:

статические объекты обозначаются именованными переменными, и действия над этими объектами производятся напрямую, с использованием их имен. Динамические объекты не имеют собственных имен, и действия над ними производятся косвенно, с помощью указателей;

выделение и освобождение памяти под статические объекты производится компилятором автоматически. Программисту не нужно самому заботиться об этом. Выделение и освобождение памяти под динамические объекты целиком и полностью возлагается на программиста. Это достаточно сложная задача, при решении которой легко наделать ошибок. Для манипуляции динамически выделяемой памятью служат операторы new и delete.

Оператор new имеет две формы. Первая форма выделяет память под единичный объект определенного типа:

int *pint = new int(1024);

Здесь оператор new выделяет память под безымянный объект типа int, инициализирует его значением 1024 и возвращает адрес созданного объекта. Этот адрес используется для инициализации указателя pint. Все действия над таким безымянным объектом производятся путем разыменовывания данного указателя, т.к. явно манипулировать динамическим объектом невозможно.

Вторая форма оператора new выделяет память под массив заданного размера, состоящий из элементов определенного типа:

int *pia = new int[4];

В этом примере память выделяется под массив из четырех элементов типа int. К сожалению, данная форма оператора new не позволяет инициализировать элементы массива.

Некоторую путаницу вносит то, что обе формы оператора new возвращают одинаковый указатель, в нашем примере это указатель на целое. И pint, и pia объявлены совершенно одинаково, однако pint указывает на единственный объект типа int, а pia – на первый элемент массива из четырех объектов типа int.

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

// îñâîáîæäåíèå åäèíè÷íîãî îáúåêòà

delete pint;

// îñâîáîæäåíèå ìàññèâà

delete[] pia;

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

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

Упражнение 2.3

Объясните разницу между четырьмя объектами:

(a) int ival = 1024;

(b) int *pi = &ival;

(c) int *pi2 = new int(1024);

(d) int *pi3 = new int[1024];

Упражнение 2.4

Что делает следующий фрагмент кода? В чем состоит логическая ошибка? (Отметим, что операция взятия индекса ([]) правильно применена к указателю pia. Объяснение этому факту можно найти в разделе 3.9.2.)

int *pi = new int(10);

int *pia = new int[10];

while ( *pi < 10 ) {

 pia[*pi] = *pi;

 *pi = *pi + 1;

}

delete pi;

delete[] pia;

2.3. Объектный подход

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

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

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

поддерживать операцию присваивания и операцию сравнения на равенство;

отвечать на некоторые вопросы, например: какова величина минимального и максимального элемента; содержит ли массив элемент с определенным значением; если да, то каков индекс первого встречающегося элемента, имеющего это значение;

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

Конечно, мы должны реализовать и базовые операции работы с массивом, а именно:Возможность задать размер массива при его создании. (Речь не идет о том, чтобы знать эту величину на этапе компиляции.)

Возможность проинициализировать массив некоторым набором значений.

Возможность обращаться к элементу массива по индексу. Пусть эта возможность реализуется с помощью стандартной операции взятия индекса.

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

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

class classname {

public:

 // набор открытых операций

private:

 // закрытые функции, обеспечивающие реализацию

};

class, public и private – это ключевые слова С++, а classname – имя, которое программист дал своему классу. Назовем наш проектируемый класс IntArray: на первом этапе этот массив будет содержать только целые числа. Когда мы научим его обращаться с данными любого типа, можно будет переименовать его в Array.

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

// статический объект типа IntArray

IntArray myArray;

// указатель на динамический объект типа IntArray

IntArray *pArray = new IntArray;

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

// объявление класса IntArray

// без определения его

class IntArray;

Тело класса состоит из определений членов и спецификаторов доступа – ключевых слов public, private и protected. (Пока мы ничего не будем говорить об уровне доступа protected.) Членами класса могут являться функции, которые определяют набор действий, выполняемых классом, и переменные, содержащие некие внутренние данные, необходимые для реализации класса. Функции, принадлежащие классу, называют функциями-членами или, по-другому, методами класса. Вот набор методов класса IntArray:

class IntArray {

public:

 // операции сравнения: #2b

 bool operator== (const IntArray&) const;

 bool operator!= (const IntArray&) const;

 // операция присваивания: #2a

 IntArray& operator= (const IntArray&);

 int size() const; // #1

 void sort();      // #4

 int min() const;  // #3a

 int max() const;  // #3b

 // функция find возвращает индекс первого

 // найденного элемента массива

 // или -1, если элементов не найдено

 int find (int value) const; // #3c

private:

 // дальше идут закрытые члены,

 // обеспечивающие реализацию класса

 ...

}

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

Именованная функция-член (например, min()) может быть вызвана с использованием одной из двух операций доступа к члену класса. Первая операция доступа, обозначаемая точкой (.), применяется к объектам класса, вторая – стрелка (->) – к указателям на объекты. Так, чтобы найти минимальный элемент в объекте, имеющем тип IntArray, мы должны написать:

// инициализация переменной min_val

// минимальным элементом myArray

int min_val = myArray.min();

Чтобы найти минимальный элемент в динамически созданном объекте типа IntArray, мы должны написать:

int min_val = pArray->min();

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

Операции применяются к объектам класса точно так же, как и к встроенным типам данных. Пусть мы имеем два объекта типа IntArray:

IntArray myАrray0, myArray1;

Инструкции присваивания и сравнения с этими объектами выглядят совершенно обычным образом:

// èíñòðóêöèÿ ïðèñâàèâàíèÿ -

// âûçûâàåò ôóíêöèþ-÷ëåí myArray0.operator=(myArray1)

myArray0 = myArray1;

// èíñòðóêöèÿ ñðàâíåíèÿ -

// âûçûâàåò ôóíêöèþ-÷ëåí myArray0.operator==(myArray1)

if (myArray0 == myArray1)

 cout << "Ура! Оператор присваивания сработал!\n";

Спецификаторы доступа public и private определяют уровень доступа к членам класса. К тем членам, которые перечислены после public, можно обращаться из любого места программы, а к тем, которые объявлены после private, могут обращаться только функции-члены данного класса. (Помимо функций-членов, существуют еще функции-друзья класса, но мы не будем говорить о них вплоть до раздела 15.2.)

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

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

если мы меняем или расширяем реализацию класса, то изменения можно выполнить так, что большинство пользовательских программ, использующих наш класс, их “не заметят”: модификации коснутся лишь скрытых членов (мы поговорим об этом в разделе 6.18);

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

Какие же внутренние данные потребуются для реализации класса IntArray? Необходимо где-то сохранить размер массива и сами его элементы. Мы будем хранить их в массиве встроенного типа, память для которого выделяется динамически. Так что нам потребуется указатель на этот массив. Вот как будут выглядеть определения этих данных-членов:

class IntArray {

public:

 // ...

 int size() const { return _size; }

private:

 // внутренние данные-члены

 int _size;

 int *ia;

};

Поскольку мы поместили член _size в закрытую секцию, пользователь класса не имеет возможности обратиться к нему напрямую. Чтобы позволить внешней программе узнать размер массива, мы написали функцию-член size(), которая возвращает значение члена _size. Нам пришлось добавить символ подчеркивания к имени нашего скрытого члена _size, поскольку функция-член с именем size() уже определена. Члены класса – функции и данные – не могут иметь одинаковые имена.

Может показаться, что реализуя подобным образом доступ к скрытым данным класса, мы очень сильно проигрываем в эффективности. Сравним два выражения (предположим, что мы изменили спецификатор доступа члена _size на public):

IntArray array;

int array_size = array.size();

array_size = array._size;

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

На самом деле, нет. С++ имеет механизм встроенных (inline) функций. Текст встроенной функции подставляется компилятором в то место, где записано обращение к ней. (Это напоминает механизм макросов, реализованный во многих языках, в том числе и в С++. Однако есть определенные отличия, о которых мы сейчас говорить не будем.) Вот пример. Если у нас есть следующий фрагмент кода:

for (int index=0; index<array.size(); ++index)

 // ...

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

for (int index=0; index<array._size; ++index)

 // ...

Если функция определена внутри тела класса (как в нашем случае), она автоматически считается встроенной. Существует также ключевое слово inline, позволяющее объявить встроенной любую функцию3.

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

Одна из самых распространенных ошибок при программировании (на любом языке) состоит в том, что объект используется без предварительной инициализации. Чтобы помочь избежать этой ошибки, С++ обеспечивает механизм автоматической инициализации для определяемых пользователем классов – конструктор класса.

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

Функция-член класса, носящее то же имя, что и сам класс, считается конструктором. (Нет никаких специальных ключевых слов, позволяющих определить конструктор как-то по-другому.) Мы уже сказали, что конструкторов может быть несколько. Как же так: разные функции с одинаковыми именами?

В С++ это возможно. Разные функции могут иметь одно и то же имя, если у этих функций различны количество и/или типы параметров. Это называется перегрузкой функции. Обрабатывая вызов перегруженной функции, компилятор смотрит не только на ее имя, но и на список параметров. По количеству и типам передаваемых параметров компилятор может определить, какую же из одноименных функций нужно вызывать в данном случае. Рассмотрим пример. Мы можем определить следующий набор перегруженных функций min(). (Перегружаться могут как обычные функции, так и функции-члены.)

// ñïèñîê ïåðåãðóæåííûõ ôóíêöèé min()

// êàæäàÿ ôóíêöèÿ îòëè÷àåòñÿ îò äðóãèõ ñïèñêîì ïàðàìåòðîâ

#include <string>

int min (const int *pia,int size);

int min (int, int);

int min (const char *str);

char min (string);

string min (string,string);

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

Итак, вернемся к нашему классу IntArray. Давайте определим для него три конструктора:

class IntArray {

public:

 explicit IntArray (int sz = DefaultArraySize);

 IntArray (int *array, int array_size);

 IntArray (const IntArray &rhs);

 // ...

private:

 static const int DefaultArraySize = 12;

}

Первый из перечисленных конструкторов

IntArray (int sz = DefaultArraySize);

называется конструктором по умолчанию, потому что он может быть вызван без параметров. (Пока не будем объяснять ключевое слово explicit.) Если при создании объекта ему задается параметр типа int, например

IntArray array1(1024);

то значение 1024 будет передано в конструктор. Если же размер не задан, допустим:

IntArray array2;

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

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

IntArray::IntArray (int sz)

{

 // èíèöèàëèçàöèÿ ÷ëåíîâ äàííûõ

 _size = sz;

 ia = new int[_size];

 // èíèöèàëèçàöèÿ ýëåìåíòîâ ìàññèâà

 for (int ix=0; ix<_size; ++ix)

   ia[ix] = 0;

}

Это определение содержит несколько упрощенный вариант реализации. Мы не позаботились о том, чтобы попытаться избежать возможных ошибок во время выполнения. Какие ошибки возможны? Во-первых, оператор new может потерпеть неудачу при выделении нужной памяти: в реальной жизни память не бесконечна. (В разделе 2.6 мы увидим, как обрабатываются подобные ситуации.) А во-вторых, параметр sz из-за небрежности программиста может иметь некорректное значение, например нуль или отрицательное.

Что необычного мы видим в таком определении конструктора? Сразу бросается в глаза первая строчка, в которой использована операция разрешения области видимости (::):

IntArray::IntArray(int sz);

Дело в том, что мы определяем нашу функцию-член (в данном случае конструктор) вне тела класса. Для того чтобы показать, что эта функция на самом деле является членом класса IntArray, мы должны явно предварить имя функции именем класса и двойным двоеточием. (Подробно области видимости разбираются в главе 8; области видимости применительно к классам рассматриваются в разделе 13.9.)

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

int ia[10] = {0,1,2,3,4,5,6,7,8,9};

IntArray iA3(ia,10);

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

IntArray::IntArray (int *array, int sz)

{

 // èíèöèàëèçàöèÿ ÷ëåíîâ äàííûõ

 _size = sz;

 ia = new int[_size];

 // èíèöèàëèçàöèÿ ýëåìåíòîâ ìàññèâà

 for (int ix=0; ix<_size; ++ix)

   ia[ix] = array[ix];

}

Третий конструктор называется копирующим конструктором. Он инициализирует один объект типа IntArray значением другого объекта IntArray. Такой конструктор вызывается автоматически при выполнении следующих инструкций:

IntArray array;

// ñëåäóþùèå äâà îáúÿâëåíèÿ ñîâåðøåííî ýêâèâàëåíòíû:

IntArray ia1 = array;

IntArray ia2 (array);

Вот как выглядит реализация копирующего конструктора для IntArray, опять-таки без обработки ошибок:

IntArray::IntArray (const IntArray &rhs )

{

 // èíèöèàëèçàöèÿ ÷ëåíîâ äàííûõ

 _size = rhs._size;

 ia = new int[_size];

 // èíèöèàëèçàöèÿ ýëåìåíòîâ ìàññèâà

 for (int ix=0; ix<_size; ++ix)

   ia[ix] = rhs.ia[ix];

}

В этом примере мы видим еще один составной тип данных – ссылку на объект, которая обозначается символом &. Ссылку можно рассматривать как разновидность указателя: она также позволяет косвенно обращаться к объекту. Однако синтаксис их использования различается: для доступа к члену объекта, на который у нас есть ссылка, следует использовать точку, а не стрелку; следовательно, мы пишем rhs._size, а не rhs->_size. (Ссылки рассматриваются в разделе 3.6.)

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

class IntArray {

public:

 explicit IntArray (int sz = DefaultArraySize);

 IntArray (int *array, int array_size);

 IntArray (const IntArray &rhs);

 // ...

private:

 void init (int sz,int *array);

 // ...

};

// функция, используемая всеми конструкторами

void IntArray::init (int sz,int *array)

{

 _size = sz;

 ia = new int[_size];

 for (int ix=0; ix<_size; ++ix)

   if ( !array )

     ia[ix] = 0;

   else

     ix[ix] = array[ix];

}

// модифицированные конструкторы

IntArray::IntArray (int sz) { init(sz,0); }

IntArray::IntArray (int *array, int array_size)

    { init (array_size,array); }

IntArray::IntArray (const IntArray &rhs)

    { init (rhs._size,rhs.ia); }

Имеется еще одна специальная функция-член – деструктор, который автоматически вызывается в тот момент, когда объект прекращает существование. Имя деструктора совпадает с именем класса, только в начале идет символ тильды (~). Основное назначение данной функции – освободить ресурсы, отведенные объекту во время его создания и использования. Применение деструкторов помогает бороться с трудно обнаруживаемыми ошибками, ведущими к утечке памяти и других ресурсов. В случае класса IntArray эта функция-член должна освободить память, выделенную в момент создания объекта. (Подробно конструкторы и деструкторы описаны в главе 14.) Вот как выглядит деструктор для IntArray:

class IntArray {

public:

 // конструкторы

 explicit IntArray (int sz = DefaultArraySize);

 IntArray (int *array, int array_size);

 IntArray (const IntArray &rhs);

 // деструктор

 ~IntArray() { delete[] ia; }

 // ...

private:

 // ...

};

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

IntArray array;

int last_pos = array.size()-1;

int temp = array[0];

array[0] = array[last_pos];

array[last_pos] = temp;

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

#include <cassert>

int& IntArray::operator[] (int index)

{

 assert (index >= 0 && index < _size);

 return ia[index];

}

Обычно для проектируемого класса перегружают операции присваивания, операцию сравнения на равенство, возможно, операции сравнения по величине и операции ввода/вывода. Как и перегруженных функций, перегруженных операторов, отличающихся типами операндов, может быть несколько. К примеру, можно создать несколько операций присваивания объекту значения другого объекта того же самого или иного типа. Конечно, эти объекты должны быть более или менее “похожи”. (Подробно о перегрузке операций мы расскажем в главе 15, а в разделе 3.15 приведем еще несколько примеров.)

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

По тому же самому соглашению функции-члены класса, определенные вне его описания, помещаются в файл с именем класса и расширением, обозначающим исходный текст С++ программы. Мы будем использовать расширение .С (напомним, что в разных системах вы можете встретиться с разными расширениями исходных текстов С++ программ) и назовем наш файл IntArray.C.

Упражнение 2.5

Ключевой особенностью класса С++ является разделение интерфейса и реализации. Интерфейс представляет собой набор операций (функций), выполняемых объектом; он определяет имя функции, возвращаемое значение и список параметров. Обычно пользователь не должен знать об объекте ничего, кроме его интерфейса. Реализация скрывает алгоритмы и данные, нужные объекту, и может меняться при развитии объекта, никак не затрагивая интерфейс. Попробуйте определить интерфейсы для одного из следующих классов (выберите любой):

(a) матрица

(b) булевское значение

(c) паспортные данные  человека

(d) дата

(e) указатель

(f) точка

Упражнение 2.6

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

Упражнение 2.7

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

2.4. Объектно-ориентированный подход

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

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

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

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

// íåóïîðÿäî÷åííûé ìàññèâ áåç ïðîâåðêè ãðàíèö èíäåêñà

class IntArray { ... };

// íåóïîðÿäî÷åííûé ìàññèâ ñ ïðîâåðêîé ãðàíèö èíäåêñà

class IntArrayRC { ... };

// óïîðÿäî÷åííûé ìàññèâ áåç ïðîâåðêè ãðàíèö èíäåêñà

class IntSortedArray { ... };

Подобное решение имеет следующие недостатки:

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

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

void process_array (IntArray&);

void process_array (IntArrayRC&);

void process_array (IntSortedArray&);

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

Парадигма объектно-ориентированного программирования позволяет осуществить все эти пожелания. Механизм наследования обеспечивает пожелания из первого пункта. Если один класс является потомком другого (например, IntArrayRC потомок класса IntArray), то наследник имеет возможность пользоваться всеми данными и функциями-членами, определенными в классе-предке. То есть класс IntArrayRC может просто использовать всю основную функциональность, предоставляемую классом IntArray, и добавить только то, что нужно ему для обеспечения проверки границ индекса.

В С++ класс, свойства которого наследуются, называют также базовым классом, а класс-наследник – производным классом, или подклассом базового. Класс и подкласс имеют общий интерфейс, предоставляемый базовым классом (т.к. подкласс имеет все функции-члены базового класса). Значит, программу, использующую только функции из этого общего интерфейса, не должен интересовать фактический тип объекта, с которым она работает, – базового ли типа этот объект или производного. В этом смысле общий интерфейс скрывает специфичные для подкласса детали. Отношения между классами и подклассами называются иерархией наследования классов. Вот как может выглядеть реализация функции swap(), которая меняет местами два указанных элемента массива. Первым параметром функции является ссылка на базовый класс IntArray:

#include <IntArray.h>

void swap (IntArray &ia, int i, int j)

{

 int temp ia[i];

 ia[i] = ia[j];

 ia[j] = temp;

}

// ниже идут обращения к функции swap:

IntArray ia;

IntArrayRC iarc;

IntSortedArray ias;

// правильно - ia имеет тип IntArray

swap (ia,0,10);

// правильно - iarc является подклассом IntArray

swap (iarc,0,10);

// правильно - ias является подклассом IntArray

swap (ias,0,10);

// ошибка - string не является подклассом IntArray

string str("Это не IntArray!");

swap (str,0,10);

Каждый из трех классов реализует операцию взятия индекса по-своему. Поэтому важно, чтобы внутри функции swap() вызывалась нужная операция взятия индекса. Так, если swap() вызвана для IntArrayRC:

swap (iarc,0,10);

то должна вызываться функция взятия индекса для объекта класса IntArrayRC, а для

swap (ias,0,10);

функция взятия индекса IntSortedArray. Именно это и обеспечивает механизм виртуальных функций С++.

Давайте попробуем сделать наш класс IntArray базовым для иерархии подклассов. Что нужно изменить в его описании? Синтаксически – совсем немного. Возможно, придется открыть для производных классов доступ к скрытым членам класса. Кроме того, те функции, которые мы собираемся сделать виртуальными, необходимо явно пометить специальным ключевым словом virtual. Основная же трудность состоит в таком изменении реализации базового класса, которая позволит ей лучше отвечать своей новой цели – служить базой для целого семейства подклассов.

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

Если используется наследование, то к этим двум группам разработчиков добавляется третья, промежуточная. Производный класс может проектировать совсем не тот человек, который проектировал базовый, и для того чтобы реализовать класс-наследник, совсем не обязательно иметь доступ к реализации базового. И хотя такой доступ может потребоваться при проектировании подкласса, от конечного пользователя обоих классов эта часть по-прежнему должна быть закрыта. К двум уровням доступа добавляется третий, в некотором смысле промежуточный, – защищенный (protected). Члены класса, объявленные как защищенные, могут использоваться классами-потомками, но никем больше. (Закрытые члены класса недоступны даже для его потомков.)

Вот как выглядит модифицированное описание класса IntArray:

class IntArray {

public:

 // конструкторы

 explicit IntArray (int sz = DefaultArraySize);

 IntArray (int *array, int array_size);

 IntArray (const IntArray &rhs);

 // виртуальный деструктор

 virtual ~IntArray() { delete[] ia; }

 // операции сравнения:

 bool operator== (const IntArray&) const;

 bool operator!= (const IntArray&) const;

 // операция присваивания:

 IntArray& operator= (const IntArray&);

 int size() const { return _size; };

 // мы убрали проверку индекса...

 virtual int& operator[](int index)

      { return ia[index]; }

 virtual void sort();

 virtual int min() const;

 virtual int max() const;

 virtual int find (int value) const;

protected:

 static const int DefaultArraySize = 12;

 void init (int sz; int *array);

 int _size;

 int *ia;

}

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

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

Теперь нам необходимо определить, реализация каких функций-членов базового класса может меняться в подклассах. Такие функции мы объявим виртуальными. Как уже отмечалось выше, реализация операции взятия индекса будет отличаться по крайней мере для подкласса IntArrayRC. Реализация операторов сравнения и функции size() одинакова для всех подклассов, следовательно, они не будут виртуальными.

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

void init (IntArray &ia)

{

 for (int ix=0; ix<ia.size(); ++ix)

   ia[ix] = ix;

}

Формальный параметр функции ia может быть ссылкой на IntArray, IntArrayRC или на IntSortedArray. Функция-член size() не является виртуальной и разрешается на этапе компиляции. А вот виртуальный оператор взятия индекса не может быть разрешен на данном этапе, поскольку реальный тип объекта, на который ссылается ia, в этот момент неизвестен.

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

Вот как выглядит определение производного класса IntArrayRC:

#ifndef IntArrayRC_H

#define IntArrayRC_H

#include "IntArray.h"

class IntArrayRC : public IntArray {

public:

   IntArrayRC( int sz = DefaultArraySize );

   IntArrayRC( const int *array, int array_size );

   IntArrayRC( const IntArrayRC &rhs );

   virtual int& operator[]( int ) const;

private:

   void check_range( int ix );

};

#endif

Этот текст мы поместим в заголовочный файл IntArrayRC.h. Обратите внимание на то, что в наш файл включен заголовочный файл IntArray.h.

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

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

class IntArrayRC : public IntArray

Эта строка показывает, что класс IntArrayRC произведен от класса IntArray, другими словами, наследует ему. Ключевое слово public в данном контексте говорит о том, что производный класс сохраняет открытый интерфейс базового класса, то есть что все открытые функции базового класса остаются открытыми и в производном. Объект типа IntArrayRC может использоваться вместо объекта типа IntArray, как, например, в приведенном выше примере с функцией swap(). Таким образом, подкласс IntArrayRC – это расширенная версия класса IntArray.

Вот как выглядит реализация операции взятия индекса:

IntArrayRC::operator[]( int index )

{

   check_range( index );

   return _ia[ index ];

}

А вот реализация встроенной функции check_range():

#include <cassert>

inline void IntArrayRC::check_range(int index)

{

   assert (index>=0 && index < _size);

}

(Мы говорили о макросе assert() в разделе 1.3.)

Почему проверка индекса вынесена в отдельную функцию, а не выполняется прямо в теле оператора взятия индекса? Потому что, если мы когда-нибудь потом захотим изменить что-то в реализации проверки, например написать свою обработку ошибок, а не использовать assert(), это будет сделать проще.

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

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

На самом деле конструкторы, как и деструкторы или операторы присваивания, не наследуются – это правило языка С++. Кроме того, конструктор производного класса обеспечивает механизм передачи параметров конструктору базового класса. Рассмотрим пример. Пусть мы хотим создать объект класса IntArrayRC следующим образом:

int ia[] = {0,1,1,2,3,5,8,13};

IntArrayRC iarc(ia,8);

Нам нужно передать параметры ia и 8 конструктору базового класса IntArray. Для этого служит специальная синтаксическая конструкция. Вот как выглядят реализации двух конструкторов IntArrayRC:

inline IntArrayRC::IntArrayRC( int sz )

   : IntArray( sz ) {}

inline IntArrayRC::IntArrayRC( const int *iar, int sz )

   : IntArray( iar, sz ) {}

(Мы будем подробно говорить о конструкторах в главах 14 и 17. Там же мы покажем, почему не нужно реализовывать конструктор копирования для IntArrayRC.)

Часть определения, следующая за двоеточием, называется списком инициализации членов. Именно здесь, указав конструктор базового класса, мы можем передать ему параметры. Тела обоих конструкторов пусты, поскольку их работа состоит исключительно в передаче параметров конструктору базового класса. Нам не нужно реализовывать деструктор для IntArrayRC, так как ему просто нечего делать. Точно так же, как при создании объекта производного типа вызывается сначала конструктор базового типа, а затем производного, при уничтожении автоматически вызываются деструкторы – естественно, в обратном порядке: сначала деструктор производного, затем базового. Таким образом, деструктор базового класса будет вызван для объекта типа IntArrayRC, хотя тот и не имеет собственной аналогичной функции.

Мы поместим все встроенные функции класса IntArrayRC в тот же заголовочный файл IntArrayRC.h. Поскольку у нас нет невстроенных функций, то создавать файл IntArrayRC.C не нужно.

Вот пример простой программы, использующей классы IntArray и IntArrayRC:

#include <iostream>

#include "IntArray.h"

#include "IntArrayRC.h"

void swap( IntArray &ia, int ix, int jx )

{

 int tmp  = ia[ ix ];

 ia[ ix ] = ia[ jx ];

 ia[ jx ] = tmp;

}

int main()

{

 int array[ 4 ] = { 0, 1, 2, 3 };

 IntArray ia1( array, 4 );

 IntArrayRC ia2( array, 4 );

 // îøèáêà: äîëæíî áûòü size-1

 // íå ìîæåò áûòü âûÿâëåíà îáúåêòîì IntArray

 cout << "swap() with IntArray ia1" << endl;

 swap( ia1, 1, ia1.size() );

 // ïðàâèëüíî: îáúåêò IntArrayRC "ïîéìàåò" îøèáêó

 cout << "swap() with IntArrayRC ia2" << endl;

 swap( ia2, 1, ia2.size() );

 return 0;

}

При выполнении программа выдаст следующий результат:

swap() with IntArray ia1

swap() with IntArrayRC ia2

Assertion failed: ix >= 0 && ix < _size,

  file IntArrayRC.h, line 19

Упражнение 2.8

Отношение наследования между типом и подтипом служит примером отношения является. Так, массив IntArrayRC является подвидом массива IntArray, книга является подвидом выдаваемых библиотекой предметов, аудиокнига является подвидом книги и т.д. Какие из следующих утверждений верны?

(a) функция-член является подвидом функции

(b) функция-член является подвидом класса

(c) конструктор является подвидом функции-члена

(d) самолет является подвидом транспортного средства

(e) машина является подвидом грузовика

(f) круг является подвидом геометрической фигуры

(g) квадрат является подвидом треугольника

(h) автомобиль является подвидом самолета

(i) читатель является подвидом библиотеки

Упражнение 2.9

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

(a) rotate();

(b) print();

(c) size();

(d) DateBorrowed(); // äàòà âûäà÷è êíèãè

(e) rewind();

(f) borrower(); // ÷èòàòåëü

(g) is_late(); // êíèãà ïðîñðî÷åíà

(h) is_on_loan(); // êíèãà âûäàíà

Упражнение 2.10

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

Упражнение 2.11

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

Упражнение 2.12

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

(a) Точка

(b) Служащий

(c) Фигура

(d) Телефонный_номер

(e) Счет_в_банке

(f) Курс_продажи

2.5. Использование шаблонов

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

Для решения данной проблемы в С++ введен механизм шаблонов. В объявлениях классов и функций допускается использование параметризованных типов. Типы-параметры заменяются в процессе компиляции настоящими типами, встроенными или определенными пользователем. Мы можем создать шаблон класса Array, заменив в классе IntArray тип элементов int на обобщенный тип-параметр. Позже мы конкретизируем типы-параметры, подставляя вместо них реальные типы int, double и string. В результате появится способ использовать эти конкретизации так, как будто мы на самом деле определили три разных класса для этих трех типов данных.

Вот как может выглядеть шаблон класса Array:

template <class elemType>

class Array {

public:

   explicit Array( int sz = DefaultArraySize );

   Array( const elemType *ar, int sz );

   Array( const Array &iA );

   virtual ~Array() { delete[] _ia; }

   Array& operator=( const Array & );

   int size() const { return _size; }

   virtual elemType& operator[]( int ix )

       { return _ia[ix]; }

   virtual void sort( int,int );

   virtual int find( const elemType& );

   virtual elemType min();

   virtual elemType max();

protected:

   void init( const elemType*, int );

   void swap( int, int );

   static const int DefaultArraySize = 12;

   int       _size;

   elemType *_ia;

};

Ключевое слово template говорит о том, что задается шаблон, параметры которого заключаются в угловые скобки (<>). В нашем случае имеется лишь один параметр elemType; ключевое слово class перед его именем сообщает, что этот параметр представляет собой тип.

При конкретизации класса-шаблона Array параметр elemType заменяется на реальный тип при каждом использовании, как показано в примере:

#include <iostream>

#include "Array.h"

int main()

{

 const int array_size = 4;

 // elemType заменяется на int

 Array<int> ia(array_size);

 // elemType заменяется на double

 Array<double> da(array_size);

 // elemType заменяется на char

 Array<char> ca(array_size);

 int ix;

 for ( ix = 0; ix < array_size; ++ix ) {

         ia[ix] = ix;

         da[ix] = ix * 1.75;

         ca[ix] = ix + 'a';

 }

 for ( ix = 0; ix < array_size; ++ix )

         cout << "[ " << ix << " ]  ia: "  << ia[ix]

             << "\tca: " << ca[ix]

             << "\tda: " << da[ix] << endl;

 return 0;

}

Здесь определены три экземпляра класса Array:

Array<int> ia(array_size);

Array<double> da(array_size);

Array<char> ca(array_size);

Что делает компилятор, встретив такое объявление? Подставляет текст шаблона Array, заменяя параметр elemType на тот тип, который указан в каждом конкретном случае. Следовательно, объявления членов приобретают в первом случае такой вид:

// Array<int> ia(array_size);

int _size;

int *_ia;

Заметим, что это в точности соответствует определению массива IntArray.

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

// Array<double> da(array_size);

int     _size;

double *_ia;

// Array<char> ca(array_size);

int   _size;

char *_ia;

Что происходит с функциями-членами? В них тоже тип-параметр elemType заменяется на реальный тип, однако компилятор не конкретизирует те функции, которые не вызываются в каком-либо месте программы. (Подробнее об этом в разделе 16.8.)

При выполнении программа этого примера выдаст следующий результат:

[ 0 ]  ia: 0    ca: a   da: 0

[ 1 ]  ia: 1    ca: b   da: 1.75

[ 2 ]  ia: 2    ca: c   da: 3.5

[ 3 ]  ia: 3    ca: d   da: 5.25

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

#include <cassert>

#include "Array.h"

template <class elemType>

class ArrayRC : public Array<elemType> {

public:

   ArrayRC( int sz = DefaultArraySize )

           : Array<elemType>( sz ) {}

   ArrayRC( const ArrayRC& r )

           : Array<elemType>( r ) {}

   ArrayRC( const elemType *ar, int sz )

           : Array<elemType>( ar, sz ) {}

   elemType& ArrayRC<elemType>::operator[]( int ix )

   {

       assert( ix >= 0 && ix < Array<elemType>::_size );

       return _ia[ ix ];

   }

private:

// ...

};

Подстановка реальных параметров вместо типа-параметра elemType происходит как в базовом, так и в производном классах. Определение

ArrayRC<int> ia_rc(10);

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

// функцию swap() тоже следует сделать шаблоном

swap( ia1, 1, ia1.size() );

был допустимым, нам потребуется представить функцию swap() в виде шаблона.

#include "Array.h"

template <class elemType>

inline void

swap( Array<elemType> &array, int i, int j )

{

 elemType tmp = array[ i ];

 array[ i ] = array[ j ];

 array[ j ] = tmp;

}

При каждом вызове swap() генерируется подходящая конкретизация, которая зависит от типа массива. Вот как выглядит программа, использующая шаблоны Array и ArrayRC:

#include <iostream>

#include "Array.h"

#include "ArrayRC.h"

template <class elemType>

inline void

swap( Array<elemType> &array, int i, int j )

{

 elemType tmp = array[ i ];

 array[ i ] = array[ j ];

 array[ j ] = tmp;

}

int main()

{

 Array<int>   ia1;

 ArrayRC<int> ia2;

 cout << "swap() with Array<int> ia1" << endl;

 int size = ia1.size();

 swap( ia1, 1, size );

 cout << "swap() with ArrayRC<int> ia2" << endl;

 size = ia2.size();

 swap( ia2, 1, size );

 return 0;

}

Упражнение 2.13

Пусть мы имеем следующие объявления типов:

template<class elemType> class Array;

enum Status { ... };

typedef string *Pstring;

Есть ли ошибки в приведенных ниже описаниях объектов?

(a) Array< int*& > pri(1024);

(b) Array< Array<int> > aai(1024);

(c) Array< complex< double > > acd(1024);

(d) Array< Status > as(1024);

(e) Array< Pstring > aps(1024);

Упражнение 2.14

Перепишите следующее определение, сделав из него шаблон класса:

class example1 {

public:

 example1 (double min, double max);

 example1 (const double *array, int size);

 double& operator[] (int index);

 bool operator== (const example1&) const;

 bool insert (const double*, int);

 bool insert (double);

 double min (double) const { return _min; };

 double max (double) const { return _max; };

 void min (double);

 void max (double);

 int count (double value) const;

private:

 int size;

 double *parray;

 double _min;

 double _max;

}

Упражнение 2.15

Имеется следующий шаблон класса:

template <class elemType> class Example2 {

public:

 explicit Example2 (elemType val=0) : _val(val) {};

 bool min(elemType value) { return _val < value; }

 void value(elemType new_val) { _val = new_val; }

 void print (ostream &os) { os << _val; }

private:

 elemType _val;

}

template <class elemType>

ostream& operator<<(ostream &os,const Example2<elemType> &ex)

 { ex.print(os); return os; }

Какие действия вызывают следующие инструкции?

(a) Example2<Array<int>*> ex1;

(b) ex1.min (&ex1);

(c) Example2<int> sa(1024),sb;

(d) sa = sb;

(e) Example2<string> exs("Walden");

(f) cout << "exs: " << exs << endl;

Упражнение 2.16

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

explicit Example2 (elemType val=0) : _val(val) {};

Однако не все типы могут быть инициализированы нулем (например, тип string), поэтому определение объекта

Example2<string> exs("Walden");

является правильным, а

Example2<string> exs2;

приведет к синтаксической ошибке4. Также ошибочным будет вызов функции min(), если для данного типа не определена операция меньше. С++ не позволяет задать ограничения для типов, подставляемых в шаблоны. Как вы думаете, было бы полезным иметь такую возможность? Если да, попробуйте придумать синтаксис задания ограничений и перепишите в нем определение класса Example2. Если нет, поясните почему.

Упражнение 2.17

Как было показано в предыдущем упражнении, попытка использовать шаблон Example2 с типом, для которого не определена операция меньше, приведет к синтаксической ошибке. Однако ошибка проявится только тогда, когда в тексте компилируемой программы действительно встретится вызов функции min(), в противном случае компиляция пройдет успешно. Как вы считаете, оправдано ли такое поведение? Не лучше ли предупредить об ошибке сразу, при обработке описания шаблона? Поясните свое мнение.

2.6. Использование исключений

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

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

Механизм исключений делится на две основные части:

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

if ( !infile ) {

 string errMsg("Íåâîçìîæíî îòêðûòü ôàéë: ");

 errMsg += fileName;

 throw errMsg;

}

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

catch (string exceptionMsg) {

 log_message (exceptionMsg);

 return false;

}

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

int* stats (const int *ia, int size)

{

 int *pstats = new int [4];

 try {

   pstats[0] = sum_it (ia,size);

   pstats[1] = min_val (ia,size);

   pstats[2] = max_val (ia,size);

 }

 catch (string exceptionMsg) {

   // êîä îáðàáîò÷èêà

 }

 catch (const statsException &statsExcp) {

   // êîä îáðàáîò÷èêà

 }

 pstats [3] = pstats[0] / size;

 do_something (pstats);

 return pstats;

}

В данном примере в теле функции stats() три оператора заключены в try-блок, а четыре – нет. Из этих четырех операторов два способны возбудить исключения.

1) int *pstats = new int [4];

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

2) do_something (pstats);

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

Необходимо заметить, что, хотя оператор

pstats [3] = pstats[0] / size;

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

Обратимся теперь к инструкциям, объединенным в try-блок. Если в одной из вызываемых в этом блоке функций – sum_it(), min_val() или max_val() –произойдет исключение, управление будет передано на обработчик, следующий за try-блоком и перехватывающий именно это исключение. Ни инструкция, возбудившая исключение, ни следующие за ней инструкции в try-блоке выполнены не будут. Представим себе, что при вызове функции sum_it() возбуждено исключение:

throw string ("Ошибка: adump27832");

Выполнение функции sum_it() прервется, операторы, следующие в try-блоке за вызовом этой функции, также не будут выполнены, и pstats[0] не будет инициализирована. Вместо этого возбуждается исключительное состояние и исследуются два catch-обработчика. В нашем случае выполняется catch с параметром типа string:

catch (string exceptionMsg) {

 // êîä îáðàáîò÷èêà

}

После выполнения управление будет передано инструкции, следующей за последним catch-обработчиком, относящимся к данному try-блоку. В нашем случае это

pstats [3] = pstats[0] / size;

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

Вот пример:

catch (string exceptionMsg) {

 // êîä îáðàáîò÷èêà

 cerr << "stats(): èñêëþ÷åíèå: "

      << exceptionMsg

      << endl;

 delete [] pstats;

 return 0;

}

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

Функция stats() умеет реагировать на два типа исключений: string и statsException. Исключение любого другого типа игнорируется, и управление передается в вызвавшую функцию, а если и в ней не найдется обработчика, – то в функцию более высокого уровня, и так до функции main().При отсутствии обработчика и там, программа аварийно завершится.

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

catch (...) {

 // îáðàáàòûâàåò ëþáîå èñêëþ÷åíèå,

 // îäíàêî åìó íåäîñòóïåí îáúåêò, ïåðåäàííûé

 // â îáðàáîò÷èê â èíñòðóêöèè throw

}

(Детально обработка исключительных ситуаций рассматривается в главах 11 и 19.)

Упражнение 2.18

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

int *alloc_and_init (string file_name)

{

 ifstream infile (file_name)

 int elem_cnt;

 infile >> elem_cnt;

 int *pi = allocate_array(elem_cnt);

 int elem;

 int index=0;

 while (cin >> elem)

   pi[index++] = elem;

 sort_array(pi,elem_cnt);

 register_data(pi);

 return pi;

}

Упражнение 2.19

В предыдущем примере вызываемые функции allocate_array(), sort_array() и register_data() могут возбуждать исключения типов noMem, int и string соответственно. Перепишите функцию alloc_and_init(), вставив соответствующие блоки try и catch для обработки этих исключений. Пусть обработчики просто выводят в cerr сообщение об ошибке.

Упражнение 2.20

Усовершенствуйте функцию alloc_and_init() так, чтобы она сама возбуждала исключение в случае возникновения всех возможных ошибок (это могут быть исключения, относящиеся к вызываемым функциям allocate_array(), sort_array() и register_data() и какими-то еще операторами внутри функции alloc_and_init()). Пусть это исключение имеет тип string и строка, передаваемая обработчику, содержит описание ошибки.

2.7. Использование пространства имен

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

class Cplusplus_Primer_Third_Edition_Array { ... };

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

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

namespace Cplusplus_Primer_3E {

 template <class elemType> class Array { ... };

}

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

namespace IBM_Canada_Laboratory {

 template <class elemType> class Array { ... };

 class Matrix { ... };

}

namespace Disney_Feature_Animation {

 class Point { ... };

 template <class elemType> class Array { ... };

}

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

Cplusplus_Primer_3E::Array<string> text;

IBM_Canada_Laboratory::Matrix mat;

Disney_Feature_Animation::Point origin(5000,5000);

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

// ïñåâäîíèìû

namespace LIB = IBM_Canada_Laboratory;

namespace DFA = Disney_Feature_Animation;

int main()

{

 LIB::Array<int> ia(1024);

}

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

namespace LIB = Cplusplus_Primer_3E;

int main()

{

 LIB::Array<int> ia(1024);

}

Конечно, чтобы это стало возможным, необходимо точное совпадение интерфейсов классов и функций, объявленных в этих пространствах имен. Представим, что класс Array из Disney_Feature_Animation не имеет конструктора с одним параметром – размером. Тогда следующий код вызовет ошибку:

namespace LIB = Disney_Feature_Animation;

int main()

{

 LIB::Array<int> ia(1024);

}

Еще более удобным является способ использования простого, неквалифицированного имени для обращения к объектам, определенным в некотором пространстве имен. Для этого существует директива using:

#include "IBM_Canada_Laboratory.h"

using namespace IBM_Canada_Laboratory;

int main()

{

 // IBM_Canada_Laboratory::Matrix

 Matrix mat(4,4);

 // IBM_Canada_Laboratory::Array

 Array<int> ia(1024);

 // ...

}

Пространство имен IBM_Canada_Laboratory становится видимым в программе. Можно сделать видимым не все пространство, а отдельные имена внутри него (селективная директива using):

#include "IBM_Canada_Laboratory.h"

using namespace IBM_Canada_Laboratory::Matrix;

// âèäèìûì ñòàíîâèòñÿ òîëüêî Matrix

int main()

{

 // IBM_Canada_Laboratory::Matrix

 Matrix mat(4,4);

 // Îøèáêà: IBM_Canada_Laboratory::Array íåâèäèì

 Array<int> ia(1024);

 // ...

}

Как мы уже упоминали, все компоненты стандартной библиотеки С++ объявлены внутри пространства имен std. Поэтому простого включения заголовочного файла недостаточно, чтобы напрямую пользоваться стандартными функциями и классами:

#include <string>

// îøèáêà: string íåâèäèì

string current_chapter = "Îáçîð Ñ++";

Íåîáõîäèìî èñïîëüçîâàòü äèðåêòèâó using:

#include <string>

using namespace std;

// Ok: âèäèì string

string current_chapter = "Обзор С++";

Заметим, однако, что таким образом мы возвращаемся к проблеме “засорения” глобального пространства имен, ради решения которой и был создан механизм именованных пространств. Поэтому лучше использовать либо квалифицированное имя:

#include <string>

// ïðàâèëüíî: êâàëèôèöèðîâàííîå èìÿ

std::string current_chapter = "Îáçîð Ñ++";

ëèáî ñåëåêòèâíóþ äèðåêòèâó using:

#include <string>

using namespace std::string;

// Ok: string âèäèì

string current_chapter = "Обзор С++";

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

В большинстве примеров этой книги директивы пространств имен были опущены. Это сделано ради сокращения размера кода, а также потому, что большинство примеров были скомпилированы компилятором, не поддерживающим пространства имен – достаточно недавнего нововведения С++. (Детали применения using-объявлений при работе с стандартной библиотекой С++ обсуждаются в разделе 8.6.)

В нижеследующих главах мы создадим еще четыре класса: String, Stack, List и модификацию Stack. Все они будут заключены в одно пространство имен – Cplusplus_Primer_3E. (Более подробно работа с пространствами имен рассматривается в главе 8.)

Упражнение 2.21

Дано пространство имен

namespace Exercize {

 template <class elemType>

   class Array { ... };

 template <class EType>

   void print (Array< EType > );

 class String { ... }

 template <class ListType>

   class List { ... };

}

и текст программы:

int main() {

 const int size = 1024;

 Array<String> as (size);

 List<int> il (size);

 // ...

 Array<String> *pas = new Array<String>(as);

 List<int> *pil = new List<int>(il);

 print (*pas);

}

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

(a) квалифицированные имена

(b) селективную директиву using

(c) механизм псевдонимов

(d) директиву using

2.8. Стандартный массив – это вектор

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

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

vector<int> ivec(10);

vector<string> svec(10);

Есть два существенных отличия нашей реализации шаблона класса Array от реализации шаблона класса vector. Первое отличие состоит в том, что вектор поддерживает как присваивание значений существующим элементам, так и вставку дополнительных элементов, то есть динамически растет во время выполнения, если программист решил воспользоваться этой его возможностью. Второе отличие более радикально и отражает существенное изменение парадигмы проектирования. Вместо того чтобы поддержать большой набор операций-членов, применимых к вектору, таких, как sort(), min(), max(), find()и так далее, класс vector предоставляет минимальный набор: операции сравнения на равенство и на меньше, size() и empty(). Более общие операции, перечисленные выше, определены как независимые обобщенные алгоритмы.

Для использования класса vector мы должны включить соответствующий заголовочный файл.

#include <vector>

// ðàçíûå ñïîñîáû ñîçäàíèÿ îáúåêòîâ òèïà vector

vector<int> vec0; // ïóñòîé âåêòîð

const int size = 8;

const int value = 1024;

// âåêòîð ðàçìåðîì 8

// êàæäûé ýëåìåíò èíèöèàëèçèðóåòñÿ 0

vector<int> vec1(size);

// âåêòîð ðàçìåðîì 8

// êàæäûé ýëåìåíò èíèöèàëèçèðóåòñÿ ÷èñëîì 1024

vector<int> vec2(size,value);

// âåêòîð ðàçìåðîì 4

// èíèöèàëèçèðóåòñÿ ÷èñëàìè èç ìàññèâà ia

int ia[4] = { 0, 1, 1, 2 };

vector<int> vec3(ia,ia+4);

// vec4 - êîïèÿ vec2

vector<int> vec4(vec2);

Так же, как наш класс Array, класс vector поддерживает операцию доступа по индексу. Вот пример перебора всех элементов вектора:

#include <vector>

extern int getSize();

void mumble()

{

 int size = getSize();

 vector<int> vec(size);

 for (int ix=0; ix<size; ++ix)

   vec[ix] = ix;

 // ...

}

Для такого перебора можно также использовать итераторную пару. Итератор – это объект класса, поддерживающего абстракцию указательного типа. В шаблоне класса vector определены две функции-члена – begin() и end(), устанавливающие итератор соответственно на первый элемент вектора и на элемент, который следует за последним. Вместе эти две функции задают диапазон элементов вектора. Используя итератор, предыдущий пример можно переписать таким образом:

#include <vector>

extern int getSize();

void mumble()

{

 int size = getSize();

 vector<int> vec(size);

 vector<int>::iterator iter = vec.begin();

 for (int ix=0; iter!=vec.end(); ++iter, ++ix)

   *iter = ix;

 // ...

}

Определение переменной iter

vector<int>::iterator iter = vec.begin();

инициализирует ее адресом первого элемента вектора vec. iterator определен с помощью typedef в шаблоне класса vector, содержащего элементы типа int. Операция инкремента

++iter

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

*iter

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

алгоритмы поиска: find(), find_if(), search(), binary_search(), count(), count_if();

алгоритмы сортировки и упорядочения: sort(), partial_sort(), merge(), partition(), rotate(), reverse(), random_shuffle();

алгоритмы удаления: unique(), remove();

численные алгоритмы: accumulate(), partial_sum(), inner_product(), adjacent_difference();

алгоритмы генерации и изменения последовательности: generate(), fill(), transform(), copy(), for_each();

алгоритмы сравнения: equal(), min(), max().

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

sort ( ivec.begin(), ivec.end() );

Чтобы применить алгоритм sort() только к первой половине вектора, мы напишем:

sort ( ivec.begin(), ivec.begin() + ivec.size()/2 );

Роль итераторной пары может играть и пара указателей на элементы встроенного массива. Пусть, например, нам дан массив:

int ia[7] = { 10, 7, 9, 5, 3, 7, 1 };

Упорядочить весь массив можно вызовом алгоритма sort():

sort ( ia, ia+7 );

Так можно упорядочить первые четыре элемента:

sort ( ia, ia+4 );

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

#include <algorithm>

Ниже приведен пример программы, использующей разнообразные алгоритмы в применении к объекту типа vector:

#include <vector>

#include <algorithm>

#include <iostream>

int ia[ 10 ] = {

   51, 23, 7, 88, 41, 98, 12, 103, 37, 6

};

int main()

{

   vector< int > vec( ia, ia+10 );

   vector<int>::iterator    it = vec.begin(),    end_it = vec.end();

   cout << "Íà÷àëüíûé ìàññèâ: ";

   for ( ; it != end_it; ++ it ) cout << *it << ' ';

   cout << "\n";

   // ñîðòèðîâêà ìàññèâà

   sort( vec.begin(), vec.end() );

   cout << "óïîðÿäî÷åííûé ìàññèâ:   ";

   it = vec.begin(); end_it = vec.end();

   for ( ; it != end_it; ++ it ) cout << *it << ' ';

       cout << "\n\n";

   int search_value;

   cout << "Ââåäèòå çíà÷åíèå äëÿ ïîèñêà: ";

   cin >> search_value;

   // ïîèñê ýëåìåíòà

   vector<int>::iterator found;

   found = find( vec.begin(), vec.end(), search_value );

   if ( found != vec.end() )

        cout << "çíà÷åíèå íàéäåíî!\n\n";

   else cout << "çíà÷åíèå íàéäåíî!\n\n";

   // èíâåðòèðîâàíèå ìàññèâà

   reverse( vec.begin(), vec.end() );

   cout << "èíâåðòèðîâàííûé ìàññèâ: ";

   it = vec.begin(); end_it = vec.end();

   for ( ; it != end_it; ++ it ) cout << *it << ' ';

     cout << endl;

}

Стандартная библиотека С++ поддерживает и ассоциативные массивы. Ассоциативный массив – это массив, элементы которого можно индексировать не только целыми числами, но и значениями любого типа. В терминологии стандартной библиотеки ассоциативный массив называется отображением (map). Например, телефонный справочник может быть представлен в виде ассоциативного массива, где индексами служат фамилии абонентов, а значениями элементов – телефонные номера:

#include <map>

#include <string>

#include "TelephoneNumber.h"

map<string, telephoneNum> telephone_directory;

(Классы векторов, отображений и других контейнеров в подробностях описываются в главе 6. Мы попробуем реализовать систему текстового поиска, используя эти классы. В главе 12 рассмотрены обобщенные алгоритмы, а в Приложении приводятся примеры их использования.)

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

Упражнение 2.22

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

string pals[] = {

 "pooh", "tiger", "piglet", "eeyore", "kanga" };

(a) vector<string> svec1(pals,pals+5);

(b) vector<int>    ivec1(10);

(c) vector<int>    ivec2(10,10);

(d) vector<string> svec2(svec1);

(e) vector<double> dvec;

Упражнение 2.23

Напишите две реализации функции min(), объявление которой приведено ниже. Функция должна возвращать минимальный элемент массива. Используйте цикл for и перебор элементов с помощью

индекса

итератора

template <class elemType>

elemType min (const vector<elemType> &vec);


Часть II

Основы языка

Код программы и данные, которыми программа манипулирует, записываются в память компьютера в виде последовательности битов. Бит – это мельчайший элемент компьютерной памяти, способная хранить либо 0, либо 1. На физическом уровне это соответствует электрическому напряжению, которое, как известно, либо есть , либо нет. Посмотрев на содержимое памяти компьютера, мы увидим что-нибудь вроде:

00011011011100010110010000111011 ...

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

Как правило, на последовательность битов накладывают какую-либо структуру, группируя биты в байты и слова. Байт содержит 8 бит, а слово – 4 байта, или 32 бита. Однако определение слова может быть разным в разных операционных системах. Сейчас начинается переход к 64-битным системам, а еще недавно были распространены системы с 16-битными словами. Хотя в подавляющем большинстве систем размер байта одинаков, мы все равно будем называть эти величины машинно-зависимыми.

Так выглядит наша последовательность битов, организованная в байты.

Рис 1.

Адресуемая машинная память

Теперь мы можем говорить, например, о байте с адресом 1040 или о слове с адресом 1024 и утверждать, что байт с адресом 1032 не равен байту с адресом 1040.

Однако мы не знаем, что же представляет собой какой-либо байт, какое-либо машинное слово. Как понять смысл тех или иных 8 бит? Для того чтобы однозначно интерпретировать значение этого байта (или слова, или другого набора битов), мы должны знать тип данных, представляемых данным байтом.

С++ предоставляет набор встроенных типов данных: символьный, целый, вещественный – и набор составных и расширенных типов: строки, массивы, комплексные числа. Кроме того, для действий с этими данными имеется базовый набор операций: сравнение, арифметические и другие операции. Есть также операторы переходов, циклов, условные операторы. Эти элементы языка С++ составляют тот набор кирпичиков, из которых можно построить систему любой сложности. Первым шагом в освоении С++ станет изучение перечисленных базовых элементов, чему и посвящена часть II данной книги.

Глава 3 содержит обзор встроенных и расширенных типов, а также механизмов, с помощью которых можно создавать новые типы. В основном это, конечно, механизм классов, представленный в разделе 2.3. В главе 4 рассматриваются выражения, встроенные операции и их приоритеты, преобразования типов. В главе 5 рассказывается об инструкциях языка. И наконец глава 6 представляет стандартную библиотеку С++ и контейнерные типы – вектор и ассоциативный массив.

3. Типы данных С++

 ýòîé ãëàâå ïðèâîäèòñÿ îáçîð âñòðîåííûõ, èëè ýëåìåíòàðíûõ, òèïîâ äàííûõ ÿçûêà Ñ++. Îíà íà÷èíàåòñÿ ñ îïðåäåëåíèÿ ëèòåðàëîâ, òàêèõ, êàê 3.14159 èëè pi, à çàòåì ââîäèòñÿ ïîíÿòèå ïåðåìåííîé, èëè îáúåêòà, êîòîðûé äîëæåí ïðèíàäëåæàòü ê îäíîìó èç òèïîâ äàííûõ. Îñòàâøàÿñÿ ÷àñòü ãëàâû ïîñâÿùåíà ïîäðîáíîìó îïèñàíèþ êàæäîãî âñòðîåííîãî òèïà. Êðîìå òîãî, ïðèâîäÿòñÿ ïðîèçâîäíûå òèïû äàííûõ äëÿ ñòðîê è ìàññèâîâ, ïðåäîñòàâëÿåìûå ñòàíäàðòíîé áèáëèîòåêîé Ñ++. Õîòÿ ýòè òèïû íå ÿâëÿþòñÿ ýëåìåíòàðíûìè, îíè î÷åíü âàæíû äëÿ íàïèñàíèÿ íàñòîÿùèõ ïðîãðàìì íà Ñ++, è íàì õî÷åòñÿ ïîçíàêîìèòü ñ íèìè ÷èòàòåëÿ êàê ìîæíî ðàíüøå. Ìû áóäåì íàçûâàòü òàêèå òèïû äàííûõ ðàñøèðåíèåì áàçîâûõ òèïîâ Ñ++.

3.1. Литералы

В С++ имеется набор встроенных типов данных для представления целых и вещественных чисел, символов, а также тип данных “символьный массив”, который служит для хранения символьных строк. Тип char служит для хранения отдельных символов и небольших целых чисел. Он занимает один машинный байт. Типы short, int и long предназначены для представления целых чисел. Эти типы различаются только диапазоном значений, которые могут принимать числа, а конкретные размеры перечисленных типов зависят от реализации. Обычно short занимает половину машинного слова, int – одно слово, long – одно или два слова. В 32-битных системах int и long, как правило, одного размера.

Типы float, double и long double предназначены для чисел с плавающей точкой и различаются точностью представления (количеством значащих разрядов) и диапазоном. Обычно float (одинарная точность) занимает одно машинное слово, double (двойная точность) – два, а long double (расширенная точность) – три.

char, short, int и long вместе составляют целые типы, которые, в свою очередь, могут быть знаковыми (signed) и беззнаковыми (unsigned). В знаковых типах самый левый бит служит для хранения знака (0 – плюс, 1 – минус), а оставшиеся биты содержат значение. В беззнаковых типах все биты используются для значения. 8-битовый тип signed char может представлять значения от -128 до 127, а unsigned char – от 0 до 255.

Когда в программе встречается некоторое число, например 1, то это число называется литералом, или литеральной константой. Константой, потому что мы не можем изменить его значение, и литералом, потому что его значение фигурирует в тексте программы. Литерал является неадресуемой величиной: хотя реально он, конечно, хранится в памяти машины, нет никакого способа узнать его адрес. Каждый литерал имеет определенный тип. Так, 0 имеет тип int, 3.14159 – тип double.

Литералы целых типов можно записать в десятичном, восьмеричном и шестнадцатеричном виде. Вот как выглядит число 20, представленное десятичным, восьмеричным и шестнадцатеричным литералами:

20     // десятичный

024    // восьмеричный

0х14   // шестнадцатеричный

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

По умолчанию все целые литералы имеют тип signed int. Можно явно определить целый литерал как имеющий тип long, приписав в конце числа букву L (используется как прописная L, так и строчная l, однако для удобства чтения не следует употреблять строчную: ее легко перепутать с 1). Буква U (или u) в конце определяет литерал как unsigned int, а две буквы – UL или LU – как тип unsigned long. Например:

128u  1024UL    1L    8Lu

Литералы, представляющие действительные числа, могут быть записаны как с десятичной точкой, так и в научной (экспоненциальной) нотации. По умолчанию они имеют тип double. Для явного указания типа float нужно использовать суффикс F или f, а для long double - L или l, но только в случае записи с десятичной точкой. Например:

3.14159F 0/1f    12.345L 0.0

3el      1.0E-3E 2.       1.0L

Слова true и false являются литералами типа bool.

Представимые литеральные символьные константы записываются как символы в одинарных кавычках. Например:

'a'    '2'    ','    ' ' (ïðîáåë)

Специальные символы (табуляция, возврат каретки) записываются как escape-последовательности . Определены следующие такие последовательности (они начинаются с символа обратной косой черты):

íîâàÿ ñòðîêà             \n

ãîðèçîíòàëüíàÿ òàáóëÿöèÿ \t

çàáîé                    \b

âåðòèêàëüíàÿ òàáóëÿöèÿ   \v

âîçâðàò êàðåòêè          \r

ïðîãîí ëèñòà             \f

çâîíîê                   \a

îáðàòíàÿ êîñàÿ ÷åðòà     \\

âîïðîñ                   \?

îäèíî÷íàÿ êàâû÷êà        \'

äâîéíàÿ êàâû÷êà          \"

escape-последовательность общего вида имеет форму \ooo, где ooo – от одной до трех восьмеричных цифр. Это число является кодом символа. Используя ASCII-код, мы можем написать следующие литералы:

\7 (çâîíîê)   \14 (íîâàÿ ñòðîêà)

\0 (null)     \062 ('2')

Символьный литерал может иметь префикс L (например, L'a'), что означает специальный тип wchar_t – двухбайтовый символьный тип, который применяется для хранения символов национальных алфавитов, если они не могут быть представлены обычным типом char, как, например, китайские или японские буквы.

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

"" (ïóñòàÿ ñòðîêà)

"a"

"\nCC\toptions\tfile.[cC]\n"

"a multi-line \

string literal signals its \

continuation with a backslash"

Фактически строковый литерал представляет собой массив символьных констант, где по соглашению языков С и С++ последним элементом всегда является специальный символ с кодом 0 (\0).

Литерал 'A' задает единственный символ А, а строковый литерал "À" – массив из двух элементов: 'À' и  \0 (пустого символа).

Раз существует тип wchar_t, существуют и литералы этого типа, обозначаемые, как и в случае с отдельными символами, префиксом L:

L"a wide string literal"

Строковый литерал типа wchar_t – это массив символов того же типа, завершенный нулем.

Если в тесте программы идут подряд два или несколько строковых литералов (типа char или wchar_t), компилятор соединяет их в одну строку. Например, следующий текст

"two" "some"

породит массив из восьми символов – twosome и завершающий нулевой символ. Результат конкатенации строк разного типа не определен. Если написать:

// this is not a good idea

"two" L"some"

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

Упражнение 3.1

Объясните разницу в определениях следующих литералов:

(a) 'a', L'a', "a", L"a"

(b) 10, 10u, 10L, 10uL, 012, 0*C

(c) 3.14, 3.14f, 3.14L

Упражнение 3.2

Какие ошибки допущены в приведенных ниже примерах?

(a) "Who goes with F\144rgus?\014"

(b) 3.14e1L

(c) "two" L"some"

(d) 1024f

(e) 3.14UL

(f) "multiple line

    comment"

3.2. Переменные

Представим себе, что мы решаем задачу возведения 2 в степень 10. Пишем:

#include <iostream>

int main() {

   // a first solution

   cout << "2 raised to the power of 10: ";

   cout << 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;

   cout << endl;

   return 0;

}

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

Но теперь нас попросили возвести 2 в 17 степень, а потом в 23. Чрезвычайно неудобно каждый раз модифицировать текст программы! И, что еще хуже, очень просто ошибиться, написав лишнюю двойку или пропустив ее... А что делать, если нужно напечатать таблицу степеней двойки от 0 до 15? 16 раз повторить две строки, имеющие общий вид:

cout << "2 в степени X\t";

cout << 2 * ... * 2;

где Х последовательно увеличивается на 1, а вместо отточия подставляется нужное число литералов?

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

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

Привлечение более сложных механизмов для той же задачи, как правило, значительно увеличивает время подготовительного этапа. Кроме того, чем более сложные механизмы применяются, тем больше вероятность ошибок. Но даже несмотря на неизбежные ошибки и неверные ходы, применение “высоких технологий” может принести выигрыш в скорости разработки, не говоря уже о том, что эти технологии значительно расширяют наши возможности. И – что интересно! – сам процесс решения может стать привлекательным.

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

#include <iostream>

int main()

{

// objects of type int

 int value = 2;

 int pow  = 10;

 cout << value << " â ñòåïåíè "

          << pow << ": \t";

 int res = 1;

 // îïåðàòîð öèêëà:

 // ïîâòîðèòü âû÷èñëåíèå res

 // äî òåõ ïîð ïîêà cnt íå ñòàíåò áîëüøå pow

 for ( int cnt=1; cnt <= pow; ++cnt )

       res = res * value;

 cout << res << endl;

}

value, pow, res и cnt – это переменные, которые позволяют хранить, модифицировать и извлекать значения. Оператор цикла for повторяет строку вычисления результата pow раз.

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

int pow( int val, int exp )

{

   for ( int res = 1; exp > 0; --exp )

         res = res * val;

   return res;

}

Теперь получить любую степень нужного числа не составит никакого труда. Вот как реализуется последняя наша задача – напечатать таблицу степеней двойки от 0 до 15:

#include <iostream>

extern int pow(int,int);

int main()

{

   int val = 2;

   int exp = 15;

   cout << "Ñòåïåíè 2\n";

   for ( int cnt=0; cnt <= exp; ++cnt )

         cout << cnt << ": "

              << pow( val, cnt ) << endl;

   return 0;

}

Конечно, наша функция pow() все еще недостаточно обобщена и недостаточно надежна. Она не может оперировать вещественными числами, неправильно возводит числа в отрицательную степень – всегда возвращает 1. Результат возведения большого числа в большую степень может не поместиться в переменную типа int, и тогда будет возвращено некоторое случайное неправильное значение. Видите, как непросто, оказывается, писать функции, рассчитанные на широкое применение? Гораздо сложнее, чем реализовать конкретный алгоритм, направленный на решение конкретной задачи.

3.2.1. Что такое переменная

Переменная, или объект – это именованная область памяти, к которой мы имеем доступ из программы; туда можно помещать значения и затем извлекать их. Каждая переменная С++ имеет определенный тип, который характеризует размер и расположение этой области памяти, диапазон значений, которые она может хранить, и набор операций, применимых к этой переменной. Вот пример определения пяти объектов разных типов:

int    student_count;

double salary;

bool   on_loan;

strins street_address;

char   delimiter;

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

собственно значение, или r-значение (от read value – значение для чтения), которое хранится в этой области памяти и присуще как переменной, так и литералу;

значение адреса области памяти, ассоциированной с переменной, или l-значение (от location value – значение местоположения) – место, где хранится r-значение; присуще только объекту.

В выражении

ch = ch - '0';

переменная ch находится и слева и справа от символа операции присваивания. Справа расположено значение для чтения (ch и символьный литерал '0'): ассоциированные с переменной данные считываются из соответствующей области памяти. Слева – значение местоположения: в область памяти, соотнесенную с переменной ch, помещается результат вычитания. В общем случае левый операнд операции присваивания должен быть l-значением. Мы не можем написать следующие выражения:

// îøèáêè êîìïèëÿöèè: çíà÷åíèÿ ñëåâà íå ÿâëÿþòñÿ l-çíà÷åíèÿìè

// îøèáêà: ëèòåðàë - íå l-çíà÷åíèå

0 = 1;

// îøèáêà: àðèôìåòè÷åñêîå âûðàæåíèå - íå l-çíà÷åíèå

salary + salary * 0.10 = new_salary;

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

// ôàéë module0.C

// îïðåäåëÿåò îáúåêò fileName

string fileName;

// ... ïðèñâîèòü fileName çíà÷åíèå

// ôàéë module1.C

// èñïîëüçóåò îáúåêò fileName

// óâû, íå êîìïèëèðóåòñÿ:

// fileName íå îïðåäåëåí â module1.C

ifstream input_file( fileName );

С++ требует, чтобы объект был известен до первого обращения к нему. Это вызвано необходимостью гарантировать правильность использования объекта в соответствии с его типом. В нашем примере модуль module1.C вызовет ошибку компиляции, поскольку переменная fileName не определена в нем. Чтобы избежать этой ошибки, мы должны сообщить компилятору об уже определенной переменной fileName. Это делается с помощью инструкции объявления переменной:

// ôàéë module1.C

// èñïîëüçóåò îáúåêò fileName

// fileName îáúÿâëÿåòñÿ, òî åñòü ïðîãðàììà ïîëó÷àåò

// èíôîðìàöèþ îá ýòîì îáúåêòå áåç âòîðè÷íîãî åãî îïðåäåëåíèÿ

extern string fileName;

ifstream input_file( fileName )

Объявление переменной сообщает компилятору, что объект с данным именем, имеющий данный тип, определен где-то в программе. Память под переменную при ее объявлении не отводится. (Ключевое слово extern рассматривается в разделе 8.2.)

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

3.2.2. Имя переменной

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

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

Таблица 3.1. Ключевые слова C++

asm

auto

bool

break

case

catch

char

class

const

const_cast

continue

default

delete

do

double

dynamic_cast

else

enum

explicit

export

extern

false

float

for

friend

goto

if

inline

int

long

mutable

namespace

new

operator

private

protected

public

register

reinterpret_cast

return

short

signed

sizeof

static

static_cast

struct

switch

template

this

throw

true

try

typedef

typeid

typename

union

unsigned

using

virtual

void

volatile

wchar_t

while

Чтобы текст вашей программы был более понятным, мы рекомендуем придерживаться общепринятых соглашений об именах объектов:

имя переменной обычно пишется строчными буквами, например index (для сравнения: Index – это имя типа, а INDEX – константа, определенная с помощью директивы препроцессора #define);

идентификатор должен нести какой-либо смысл, поясняя назначение объекта в программе, например: birth_date или salary;

если такое имя состоит из нескольких слов, как, например, birth_date, то принято либо разделять слова символом подчеркивания (birth_date), либо писать каждое следующее слово с большой буквы (birthDate). Замечено, что программисты, привыкшие к ОбъектноОриентированномуПодходу предпочитают выделять слова заглавными буквами, в то время как те_кто_много_писал_на_С используют символ подчеркивания. Какой из двух способов лучше – вопрос вкуса.

3.2.3. Определение объекта

В самом простом случае оператор определения объекта состоит из спецификатора типа и имени объекта и заканчивается точкой с запятой. Например:

double salary;

double wage;

int month;

int day;

int year;

unsigned long distance;

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

double salary, wage;

int month,

   day, year;

unsigned long distance;

Простое определение переменной не задает ее начального значения. Если объект определен как глобальный, спецификация С++ гарантирует, что он будет инициализирован нулевым значением. Если же переменная локальная  либо динамически размещаемая (с помощью оператора new), ее начальное значение не определено, то есть она может содержать некоторое случайное значение.

Использование подобных переменных – очень распространенная ошибка, которую к тому же трудно обнаружить. Рекомендуется явно указывать начальное значение объекта, по крайней мере в тех случаях, когда неизвестно, может ли объект инициализировать сам себя. Механизм классов вводит понятие конструктора по умолчанию, который служит для присвоения значений по умолчанию. (Мы уже сказали об этом в разделе 2.3. Разговор о конструкторах по умолчанию будет продолжен немного позже, в разделах 3.11 и 3.15, где мы будем разбирать классы string и complex из стандартной библиотеки.)

int main() {

   // íåèíèöèàëèçèðîâàííûé ëîêàëüíûé îáúåêò

   int ival;

   // îáúåêò òèïà string èíèöèàëèçèðîâàí

   // êîíñòðóêòîðîì ïî óìîë÷àíèþ

   string project;

   // ...

}

Начальное значение может быть задано прямо в операторе определения переменной. В С++ допустимы две формы инициализации переменной – явная, с использованием оператора присваивания:

int ival = 1024;

string project = "Fantasia 2000";

и неявная, с заданием начального значения в скобках:

int ival( 1024 );

string project( "Fantasia 2000" );

Оба варианта эквивалентны и задают начальные значения для целой переменной ival как 1024 и для строки project как "Fantasia 2000".

Явную инициализацию можно применять и при определении переменных списком:

double salary = 9999.99, wage = salary + 0.01;

int month = 08;

     day = 07, year = 1955;

Переменная становится видимой (и допустимой в программе) сразу после ее определения, поэтому мы могли проинициализировать переменную wage суммой только что определенной переменной salary с некоторой константой. Таким образом, определение:

// êîððåêòíî, íî áåññìûñëåííî

int bizarre = bizarre;

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

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

// ival ïîëó÷àåò çíà÷åíèå 0, à dval - 0.0

int ival = int();

double dval = double();

В следующем определении:

// int() ïðèìåíÿåòñÿ ê êàæäîìó èç 10 ýëåìåíòîâ

vector< int > ivec( 10 );

к каждому из десяти элементов вектора применяется инициализация с помощью int(). (Мы уже говорили о классе vector в разделе 2.8. Более подробно об этом см. в разделе 3.10 и главе 6.)

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

#include <cmath>

#include <string>

double price = 109.99, discount = 0.16;

double sale_price( price * discount );

string pet( "wrinkles" );

extern int get_value();

int val =  get_value();

unsigned abs_val = abs( val );

abs() – стандартная функция, возвращающая абсолютное значение параметра. get_value() – некоторая пользовательская функция, возвращающая целое значение.

Упражнение 3.3

Какие из приведенных ниже определений переменных содержат синтаксические ошибки?

(a) int car = 1024, auto = 2048;

(b) int ival = ival;

(c) int ival( int() );

(d) double salary = wage = 9999.99;

(e) cin >> int input_value;

Упражнение 3.4

Объясните разницу между l-значением и r-значением. Приведите примеры.

Упражнение 3.5

Найдите отличия в использовании переменных name и student в первой и второй строчках каждого примера:

(a) extern string name;

   string name( "exercise 3.5a" );

(b) extern vector<string> students;

   vector<string> students;

Упражнение 3.6

Какие имена объектов недопустимы в С++? Измените их так, чтобы они стали синтаксически правильными:

(a) int double = 3.14159; (b) vector< int > _;

(c) string namespase;     (d) string catch-22;

(e) char 1_or_2 = '1';    (f) float Float = 3.14f;

Упражнение 3.7

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

string global_class;

int global_int;

int main() {

   int local_int;

   string local_class;

   // ...

}

3.3. Указатели

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

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

указатель на int, содержащий значение адреса 1000, направлен на область памяти 1000-1003 (в 32-битной системе);

указатель на double, содержащий значение адреса 1000, направлен на область памяти 1000-1007 (в 32-битной системе).

Вот несколько примеров:

int             *ip1, *ip2;

complex<double> *cp;

string          *pstring;

vector<int>     *pvec;

double          *dp;

Указатель обозначается звездочкой перед именем. В определении переменных списком звездочка должна стоять перед каждым указателем (см. выше: ip1 и ip2). В примере ниже lp – указатель на объект типа long, а lp2 – объект типа long:

long *lp, lp2;

В следующем случае fp интерпретируется как объект типа float, а fp2 – указатель на него:

float fp, *fp2;

Оператор разыменования (*) может отделяться пробелами от имени и даже непосредственно примыкать к ключевому слову типа. Поэтому приведенные определения синтаксически правильны и совершенно эквивалентны:

string *ps;

string* ps;

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

//внимание: ps2 не указатель на строку!

string* ps, ps2;

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

Если значение указателя равно 0, значит, он не содержит никакого адреса объекта.

Пусть задана переменная типа int:

int ival = 1024;

Ниже приводятся примеры определения и использования указателей на int pi и pi2:

//pi èíèöèàëèçèðîâàí íóëåâûì àäðåñîì

int *pi = 0;

// pi2 èíèöèàëèçèðîâàí àäðåñîì ival

int *pi2 = &ival;

// ïðàâèëüíî: pi è pi2 ñîäåðæàò àäðåñ ival

pi = pi2;

// pi2 ñîäåðæèò íóëåâîé àäðåñ

pi2 = 0;

Указателю не может быть присвоена величина, не являющаяся адресом:

// îøèáêà: pi íå ìîæåò ïðèíèìàòü çíà÷åíèå int

pi = ival

Точно так же нельзя присвоить указателю одного типа значение, являющееся адресом объекта другого типа. Если определены следующие переменные:

double dval;

double *ps = &dval;

то оба выражения присваивания, приведенные ниже, вызовут ошибку компиляции:

// îøèáêè êîìïèëÿöèè

// íåäîïóñòèìîå ïðèñâàèâàíèå òèïîâ äàííûõ: int* <== double*

pi = pd

pi = &dval;

Дело не в том, что переменная pi не может содержать адреса объекта dval – адреса объектов разных типов имеют одну и ту же длину. Такие операции смешения адресов запрещены сознательно, потому что интерпретация объектов компилятором зависит от типа указателя на них.

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

// ïðàâèëüíî: void* ìîæåò ñîäåðæàòü

// àäðåñà ëþáîãî òèïà

void *pv = pi;

pv = pd;

Тип объекта, на который указывает void*, неизвестен, и мы не можем манипулировать этим объектом. Все, что мы можем сделать с таким указателем, – присвоить его значение другому указателю или сравнить с какой-либо адресной величиной. (Более подробно мы расскажем об указателе типа void в разделе 4.14.)

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

int ival = 1024;, ival2 = 2048;

int *pi = &ival;

мы можем читать и сохранять значение ival, применяя операцию разыменования к указателю pi:

// косвенное присваивание переменной ival значения ival2

*pi = ival2;

// косвенное использование переменной ival как rvalue и lvalue

*pi = abs(*pi); // ival = abs(ival);

*pi = *pi + 1;  // ival = ival + 1;

Когда мы применяем операцию взятия адреса (&) к объекту типа int, то получаем результат типа int*

int *pi = &ival;

Если ту же операцию применить к объекту типа int* (указатель на int), мы получим указатель на указатель на int, т.е. int**. int** – это адрес объекта, который содержит адрес объекта типа int. Разыменовывая ppi, мы получаем объект типа int*, содержащий адрес ival. Чтобы получить сам объект ival, операцию разыменования к ppi необходимо применить дважды.

int **ppi = &pi;

int *pi2 = *ppi;

cout << "Çíà÷åíèå ival\n"

    << "ÿâíîå çíà÷åíèå: " << ival << "\n"

    << "êîñâåííàÿ àäðåñàöèÿ: " << *pi << "\n"

    << "äâàæäû êîñâåííàÿ àäðåñàöèÿ: " << **ppi << "\n"

    << endl;

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

int i, j, k;

int *pi = &i;

// i = i + 2

*pi = *pi + 2;

// óâåëè÷åíèå àäðåñà, ñîäåðæàùåãîñÿ â pi, íà 2

pi = pi + 2;

К указателю можно прибавлять целое значение, можно также вычитать из него. Прибавление к указателю 1 увеличивает содержащееся в нем значение на размер области памяти, отводимой объекту соответствующего типа. Если тип char занимает 1 байт, int – 4 и double – 8, то прибавление 2 к указателям на char, int и double увеличит их значение соответственно на 2, 8 и 16. Как это можно интерпретировать? Если объекты одного типа расположены в памяти друг за другом, то увеличение указателя на 1 приведет к тому, что он будет указывать на следующий объект. Поэтому арифметические действия с указателями чаще всего применяются при обработке массивов; в любых других случаях они вряд ли оправданы.

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

int ia[10];

int *iter = &ia[0];

int *iter_end = &ia[10];

while (iter != iter_end) {

 do_something_with_value (*iter);

 ++iter;

}

Упражнение 3.8

Даны определения переменных:

int ival = 1024, ival2 = 2048;

int *pi1 = &ival, *pi2 = &ival2, **pi3 = 0;

Что происходит при выполнении нижеследующих операций присваивания? Допущены ли в данных примерах ошибки?

(a) ival = *pi3;   (e) pi1 = *pi3;

(b) *pi2 = *pi3;   (f) ival = *pi1;

(c) ival = pi2;    (g) pi1 = ival;

(d) pi2 = *pi1;    (h) pi3 = &pi2;

Упражнение 3.9

Работа с указателями – один из важнейших аспектов С и С++, однако в ней легко допустить ошибку. Например, код

pi = &ival;

pi = pi + 1024;

почти наверняка приведет к тому, что pi будет указывать на случайную область памяти. Что делает этот оператор присваивания и в каком случае он не приведет к ошибке?

Упражнение 3.10

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

int foobar(int *pi) {

 *pi = 1024;

 return *pi;

}

int main() {

 int *pi2 = 0;

 int ival = foobar(pi2);

 return 0;

}

В чем состоит ошибка? Как можно ее исправить?

Упражнение 3.11

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

3.4. Строковые типы

В С++ поддерживаются два типа строк – встроенный тип, доставшийся от С, и класс string из стандартной библиотеки С++. Класс string предоставляет гораздо больше возможностей и поэтому удобней в применении, однако на практике нередки ситуации, когда необходимо пользоваться встроенным типом либо хорошо понимать, как он устроен. (Одним из примеров может являться разбор параметров командной строки, передаваемых в функцию main(). Мы рассмотрим это в главе 7.)

3.4.1. Встроенный строковый тип

Как уже было сказано, встроенный строковый тип перешел к С++ по наследству от С. Строка символов хранится в памяти как массив, и доступ к ней осуществляется при помощи указателя типа char*. Стандартная библиотека С предоставляет набор функций для манипулирования строками. Например:

// âîçâðàùàåò äëèíó ñòðîêè

int strlen( const char* );

// ñðàâíèâàåò äâå ñòðîêè

int strcmp( const char*, const char* );

// êîïèðóåò îäíó ñòðîêó â äðóãóþ

char* strcpy( char*, const char* );

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

#include <cstring>

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

const char *st = "Цена бутылки вина\n";

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

Обычно для перебора символов строки применяется адресная арифметика. Поскольку строка всегда заканчивается нулевым символом, можно увеличивать указатель на 1, пока очередным символом не станет нуль. Например:

while (*st++ ) { ... }

st разыменовывается, и получившееся значение проверяется на истинность. Любое отличное от нуля значение считается истинным, и, следовательно, цикл заканчивается, когда будет достигнут символ с кодом 0. Операция инкремента ++  прибавляет 1 к указателю st и таким образом сдвигает его к следующему символу.

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

int string_length( const char *st )

{

   int cnt = 0;

   if ( st )

        while ( *st++ )

                ++cnt;

   return cnt;

}

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

// pc1 íå àäðåñóåò íèêàêîãî ìàññèâà ñèìâîëîâ

char *pc1 = 0;

// pc2 àäðåñóåò íóëåâîé ñèìâîë

const char *pc2 = "";

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

#include <iostream>

const char *st = "Öåíà áóòûëêè âèíà\n";

int main() {

   int len = 0;

   while ( st++ ) ++len;

   cout << len << ": " << st;

   return 0;

}

В этой версии указатель st не разыменовывается. Следовательно, на равенство 0 проверяется не символ, на который указывает st, а сам указатель. Поскольку изначально этот указатель имел ненулевое значение (адрес строки), то он никогда не станет равным нулю, и цикл будет выполняться бесконечно.

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

#include <iostream>

const char *st = "Öåíà áóòûëêè âèíà\n";

int main()

{

   int len = 0;

   while ( *st++ ) ++len;

   cout << len << ": " << st << endl;

   return 0;

}

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

Можно попробовать исправить эту ошибку:

st = st – len;

cout << len << ": " << st;

Теперь наша программа выдает что-то осмысленное, но не до конца. Ответ выглядит так:

18: åíà áóòûëêè âèíà

Мы забыли учесть, что заключительный нулевой символ не был включен в подсчитанную длину. st должен быть смещен на длину строки плюс 1. Вот, наконец, правильный оператор:

st = st – len - 1;

а вот и и правильный результат:

18: Öåíà áóòûëêè âèíà

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

st = st – len - 1;

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

const char *p = st;

Теперь p можно использовать в цикле вычисления длины, оставив значение st неизменным:

while ( *p++ )

3.4.2. Класс string

Как мы только что видели, применение встроенного строкового типа чревато ошибками и не очень удобно из-за того, что он реализован на слишком низком уровне. Поэтому достаточно распространена разработка собственного класса или классов для представления строкового типа – чуть ли не каждая компания, отдел или индивидуальный проект имели свою собственную реализацию строки. Да что говорить, в предыдущих двух изданиях этой книги мы делали то же самое! Это порождало проблемы совместимости и переносимости программ. Реализация стандартного класса string стандартной библиотекой С++ призвана была положить конец этому изобретению велосипедов.

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

инициализация массивом символов (строкой встроенного типа) или другим объектом типа string. Встроенный тип не обладает второй возможностью;

копирование одной строки в другую. Для встроенного типа приходится использовать функцию strcpy();

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

сравнение двух строк на равенство. Для встроенного типа используется функция strcmp();

конкатенация двух строк, получая результат либо как третью строку, либо вместо одной из исходных. Для встроенного типа применяется функция strcat(), однако чтобы получить результат в новой строке, необходимо последовательно задействовать функции strcpy() и strcat();

вычисление длины строки. Узнать длину строки встроенного типа можно с помощью функции strlen();

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

char str = 0;

//...

if ( ! str || ! *str )

    return;

Класс string стандартной библиотеки С++ реализует все перечисленные операции (и гораздо больше, как мы увидим в главе 6). В данном разделе мы научимся пользоваться основными операциями этого класса.

Для того чтобы использовать объекты класса string, необходимо включить соответствующий заголовочный файл:

#include <string>

Вот пример строки из предыдущего раздела, представленной объектом типа string и инициализированной строкой символов:

#include <string>

string st( "Цена бутылки вина\n" );

Длину строки возвращает функция-член size() (длина не включает завершающий нулевой символ).

cout << "Äëèíà "

    << st

    << ": " << st.size()

    << " символов, включая символ новой строки\n";

Вторая форма определения строки задает пустую строку:

string st2; // пустая строка

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

if ( ! st.size() )

    // правильно: пустая

Однако есть и специальный метод empty(), возвращающий true для пустой строки и false для непустой:

if ( st.empty() )

    // правильно: пустая

Третья форма конструктора инициализирует объект типа string другим объектом того же типа:

string st3( st );

Строка st3 инициализируется строкой st. Как мы можем убедиться, что эти строки совпадают? Воспользуемся оператором сравнения (==):

if ( st == st3 )

    // инициализация сработала

Как скопировать одну строку в другую? С помощью обычной операции присваивания:

st2 = st3; // копируем st3 в st2

Для конкатенации строк используется операция сложения (+) или операция сложения с присваиванием (+=). Пусть даны две строки:

string s1( "hello, " );

string s2( "world\n" );

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

string s3 = s1 + s2;

Если же мы хотим добавить s2 в конец s1, мы должны написать:

s1 += s2;

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

const char *pc = ", ";

string s1( "hello" );

string s2( "world" );

string s3 = s1 + pc + s2 + "\n";

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

string s1;

const char *pc = "a character array";

s1 = pc; // правильно

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

char *str = s1; // ошибка компиляции

Чтобы осуществить такое преобразование, необходимо явно вызвать функцию-член с несколько странным названием c_str():

char *str = s1.c_str(); // почти правильно

Функция c_str() возвращает указатель на символьный массив, содержащий строку объекта string в том виде, в каком она находилась бы во встроенном строковом типе.

Приведенный выше пример инициализации указателя char *str все еще не совсем корректен. c_str() возвращает указатель на константный массив, чтобы предотвратить возможность непосредственной модификации содержимого объекта через этот указатель, имеющий тип

const char *

(В следующем разделе мы расскажем о ключевом слове const). Правильный вариант инициализации выглядит так:

const char *str = s1.c_str(); // правильно

К отдельным символам объекта типа string, как и встроенного типа, можно обращаться с помощью операции взятия индекса. Вот, например, фрагмент кода, заменяющего все точки символами подчеркивания:

string str( "fa.disney.com" );

int size = str.size();

for ( int ix = 0; ix < size; ++ix )

     if ( str[ ix ] == '.' )

          str[ ix ] = '_';

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

replace( str.begin(), str.end(), '.', '_' );

replace() – один из обобщенных алгоритмов, с которыми мы познакомились в разделе 2.8 и которые будут детально разобраны в главе 12. Эта функция пробегает диапазон от begin() до end(), которые возвращают указатели на начало и конец строки, и заменяет элементы, равные третьему своему параметру, на четвертый.

Упражнение 3.12

Найдите ошибки в приведенных ниже операторах:

(a) char ch = "The long and winding road";

(b) int ival = &ch;

(c) char *pc = &ival;

(d) string st( &ch );

(e) pc = 0;     (i) pc = '0';

(f) st = pc;    (j) st = &ival;

(g) ch = pc[0]; (k) ch = *pc;

(h) pc = st;    (l) *pc = ival;

Упражнение 3.13

Объясните разницу в поведении следующих операторов цикла:

while ( st++ )

       ++cnt;

while ( *st++ )

       ++cnt;

Упражнение 3.14

Даны две семантически эквивалентные программы. Первая использует встроенный строковый тип, вторая – класс string:

// ***** Реализация с использованием C-строк *****

#include <iostream>

#include <cstring>

int main()

{

   int errors = 0;

   const char *pc = "a very long literal string";

   for ( int ix = 0; ix < 1000000; ++ix )

   {

         int len = strlen( pc );

         char *pc2 = new char[ len + 1 ];

         strcpy( pc2, pc );

         if ( strcmp( pc2, pc ))

              ++errors;

         delete [] pc2;

   }

   cout << "C-строки: "

        << errors << " ошибок.\n";

}

// ***** Реализация с использованием класса string *****

#include <iostream>

#include <string>

int main()

{

   int errors = 0;

   string str( "a very long literal string" );

   for ( int ix = 0; ix < 1000000; ++ix )

   {

         int len = str.size();

         string str2 = str;

         if ( str != str2 )

   }

   cout << "класс string: "

        << errors << " ошибок.\n;

}

Что эти программы делают?

Оказывается, вторая реализация выполняется в два раза быстрее первой. Ожидали ли вы такого результата? Как вы его объясните?

Упражнение 3.15

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

3.5. Спецификатор const

Возьмем следующий пример кода:

for ( int index = 0; index < 512; ++index )

     ... ;

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

Вторая проблема касается простоты модификации и сопровождения кода. Предположим, программа состоит из 10 000 строк, и литерал 512 встречается в 4% из них. Допустим, в 80% случаев число 512 должно быть изменено на 1024. Способны ли вы представить трудоемкость такой работы и количество ошибок, которые можно сделать, исправив не то значение?

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

index < bufSize

В этом случае изменение размера bufSize не требует просмотра 400 строк кода для модификации 320 из них. Насколько уменьшается вероятность ошибок ценой добавления всего одного объекта! Теперь значение 512 локализовано.

int bufSize = 512; // ðàçìåð áóôåðà ââîäà

// ...

for ( int index = 0; index < bufSize; ++index )

     // ...

Остается одна маленькая проблема: переменная bufSize здесь является l-значением, которое можно случайно изменить в программе, что приведет к трудно отлавливаемой ошибке. Вот одна из распространенных ошибок – использование операции присваивания (=) вместо сравнения (==):

// ñëó÷àéíîå èçìåíåíèå çíà÷åíèÿ bufSize

if ( bufSize = 1 )

    // ...

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

Использование спецификатора const решает данную проблему. Объявив объект как

const int bufSize = 512; // размер буфера ввода

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

// îøèáêà: ïîïûòêà ïðèñâàèâàíèÿ çíà÷åíèÿ êîíñòàíòå

if ( bufSize = 0 ) ...

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

const double pi; // ошибка: неинициализированная константа

Давайте рассуждать дальше. Явная трансформация значения константы пресекается компилятором. Но как быть с косвенной адресацией? Можно ли присвоить адрес константы некоторому указателю?

const double minWage = 9.60;

// ïðàâèëüíî? îøèáêà?

double *ptr = &minWage;

Должен ли компилятор разрешить подобное присваивание? Поскольку minWage – константа, ей нельзя присвоить значение. С другой стороны, ничто не запрещает нам написать:

*ptr += 1.40; // изменение объекта minWage!

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

Что же, мы лишены возможности использовать указатели на константы? Нет. Для этого существуют указатели, объявленные со спецификатором const:

const double *cptr;

где cptr – указатель на объект типа const double. Тонкость заключается в том, что сам указатель – не константа, а значит, мы можем изменять его значение. Например:

const double *pc = 0;

const double minWage = 9.60;

// правильно: не можем изменять minWage с помощью pc

pc = &minWage;

double dval = 3.14;

// правильно: не можем изменять minWage с помощью pc

// хотя dval и не константа

pc = &dval; // правильно

dval = 3.14159; //правильно

*pc = 3.14159; // ошибка

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

pc = &dval;

Константный указатель не позволяет изменять адресуемый им объект с помощью косвенной адресации. Хотя dval в примере выше и не является константой, компилятор не допустит изменения переменной dval через pc. (Опять-таки потому, что он не в состоянии определить, адрес какого объекта может содержать указатель в произвольный момент выполнения программы.)

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

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

// употребляются как формальные параметры функций

int strcmp( const char *str1, const char *str2 );

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

Существуют и константные указатели. (Обратите внимание на разницу между константным указателем и указателем на константу!). Константный указатель может адресовать как константу, так и переменную. Например:

int errNumb = 0;

int *const currErr = &errNumb;

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

do_something();

if ( *curErr ) {

     errorHandler();

     *curErr = 0; // правильно: обнулим значение errNumb

}

Попытка присвоить значение константному указателю вызовет ошибку компиляции:

curErr = &myErNumb; // ошибка

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

const double pi = 3.14159;

const double *const pi_ptr = &pi;

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

Упражнение 3.16

Объясните значение следующих пяти определений. Есть ли среди них ошибочные?

(a) int i;          (d) int *const cpi;

(b) const int ic;   (e) const int *const cpic;

(c) const int *pic;

Упражнение 3.17

Какие из приведенных определений правильны? Почему?

(a) int i = -1;

(b) const int ic = i;

(c) const int *pic = &ic;

(d) int *const cpi = &ic;

(e) const int *const cpic = &ic;

Упражнение 3.18

Используя определения из предыдущего упражнения, укажите правильные операторы присваивания. Объясните.

(a) i = ic;     (d) pic = cpic;

(b) pic = &ic;  (i) cpic = &ic;

(c) cpi = pic;  (f) ic = *cpic;

3.6. Ссылочный тип

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

Ссылочный тип обозначается указанием оператора взятия адреса (&) перед именем переменной. Ссылка должна быть инициализирована. Например:

int ival = 1024;

// правильно: refVal - ссылка на ival

int &refVal = ival;

// ошибка: ссылка должна быть инициализирована

int &refVal2;

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

int ival = 1024;

// ошибка: refVal имеет тип int, а не int*

int &refVal = &ival;

int *pi = &ival;

// правильно: ptrVal - ссылка на указатель

int *&ptrVal2 = pi;

Определив ссылку, вы уже не сможете изменить ее так, чтобы работать с другим объектом (именно поэтому ссылка должна быть инициализирована в месте своего определения). В следующем примере оператор присваивания не меняет значения refVal, новое значение присваивается переменной ival – ту,  которую адресует refVal.

int min_val = 0;

// ival получает значение min_val,

// а не refVal меняет значение на min_val

refVal = min_val;

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

refVal += 2;

прибавляет 2 к ival – переменной, на которую ссылается refVal. Аналогично

int ii = refVal;

присваивает ii текущее значение ival,

int *pi = &refVal;

инициализирует pi адресом ival.

Если мы определяем ссылки в одной инструкции через запятую, перед каждым объектом типа ссылки должен стоять амперсанд (&) – оператор взятия адреса (точно так же, как и для указателей). Например:

// определено два объекта типа int

int ival = 1024, ival2 = 2048;

// определена одна ссылка и один объект

int &rval = ival, rval2 = ival2;

// определен один объект, один указатель и одна ссылка

int inal3 = 1024, *pi = ival3, &ri = ival3;

// определены две ссылки

int &rval3 = ival3, &rval4 = ival2;

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

double dval = 3.14159;

// верно только для константных ссылок

const int &ir = 1024;

const int &ir2 = dval;

const double &dr = dval + 1.0;

Если бы мы не указали спецификатор const, все три определения ссылок вызвали бы ошибку компиляции. Однако, причина, по которой компилятор не пропускает таких определений, неясна. Попробуем разобраться.

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

double dval = 1024;

const int &ri = dval;

то компилятор преобразует это примерно так:

int temp = dval;

const int &ri = temp;

Если бы мы могли присвоить новое значение ссылке ri, мы бы реально изменили не dval, а temp. Значение dval осталось бы тем же, что совершенно неочевидно для программиста. Поэтому компилятор запрещает такие действия, и единственная возможность проинициализировать ссылку объектом другого типа – объявить ее как const.

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

const int ival = 1024;

// ошибка: нужна константная ссылка

int *&pi_ref = &ival;

Попытка исправить дело добавлением спецификатора const тоже не проходит:

const int ival = 1024;

// все равно ошибка

const int *&pi_ref = &ival;

В чем причина? Внимательно прочитав определение, мы увидим, что pi_ref является ссылкой на константный указатель на объект типа int. А нам нужен неконстантный указатель на константный объект, поэтому правильной будет следующая запись:

const int ival = 1024;

// правильно

int *const &piref = &ival;

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

int *pi = 0;

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

const int &ri = 0;

означает примерно следующее:

int temp = 0;

const int &ri = temp;

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

int ival = 1024, ival2 = 2048;

int *pi = &ival, *pi2 = &ival2;

pi = pi2;

переменная ival, на которую указывает pi, остается неизменной, а pi получает значение адреса переменной ival2. И pi, и pi2 и теперь указывают на один и тот же объект ival2.

Если же мы работаем со ссылками:

int &ri = ival, &ri2 = ival2;

ri = ri2;

то само значение ival меняется, но ссылка ri по-прежнему адресует ival.

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

// пример использования ссылок

// Значение возвращается в параметре next_value

bool get_next_value( int &next_value );

// перегруженный оператор

Matrix operator+( const Matrix&, const Matrix& );

Как соотносятся самостоятельные объекты-ссылки и ссылки-параметры? Если мы пишем:

int ival;

while (get_next_value( ival )) ...

это равносильно следующему определению ссылки внутри функции:

int &next_value = ival;

(Подробнее использование ссылок в качестве формальных параметров функций рассматривается в главе 7.)

Упражнение 3.19

Есть ли ошибки в данных определениях? Поясните. Как бы вы их исправили?

(a) int ival = 1.01;       (b) int &rval1 = 1.01;

(c) int &rval2 = ival;     (d) int &rval3 = &ival;

(e) int *pi = &ival;       (f) int &rval4 = pi;

(g) int &rval5 = pi*;      (h) int &*prval1 = pi;

(i) const int &ival2 = 1;  (j) const int &*prval2 = &ival;

Упражнение 3.20

Если ли среди нижеследующих операций присваивания ошибочные (используются определения из предыдущего упражнения)?

(a) rval1 = 3.14159;

(b) prval1 = prval2;

(c) prval2 = rval1;

(d) *prval2 = ival2;

Упражнение 3.21

Найдите ошибки в приведенных инструкциях:

(a) int ival = 0;

   const int *pi = 0;

   const int &ri = 0;

(b) pi = &ival;

   ri = &ival;

   pi = &rval;

3.7. Тип bool

Объект типа bool может принимать одно из двух значений: true и false. Например:

// инициализация строки

string search_word = get_word();

// инициализация переменной found

bool found = false;

string next_word;

while ( cin >> next_word )

  if ( next_word == search_word )

       found = true;

// ...

// сокращенная запись: if ( found == true )

if ( found )

     cout << "ok, мы нашли слово\n";

else cout << "нет, наше слово не встретилось.\n";

Хотя bool относится к одному из целых типов, он не может быть объявлен как signed, unsigned, short или long, поэтому  приведенное определение ошибочно:

// ошибка

short bool found = false;

Объекты типа bool неявно преобразуются в тип int. Значение true превращается в 1, а false – в 0. Например:

bool found = false;

int occurrence_count = 0;

while ( /* mumble */ )

{

  found = look_for( /* something */ );

  // значение found преобразуется в 0 или 1

  occurrence_count += found;

}

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

// возвращает количество вхождений

extern int find( const string& );

bool found = false;

if ( found = find( "rosebud" ))

    // правильно: found == true

// возвращает указатель на элемент

extern int* find( int value );

if ( found = find( 1024 ))

    // правильно: found == true

3.8. Перечисления

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

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

const int input = 1;

const int output = 2;

const int append = 3;

и пользоваться этими константами:

bool open_file( string file_name, int open_mode);

// ...

open_file( "Phoenix_and_the_Crane", append );

Подобное решение допустимо, но не вполне приемлемо, поскольку мы  не можем гарантировать, что аргумент, передаваемый в функцию open_file()  равен только 1, 2 или 3.

Использование перечислимого типа решает данную проблему. Когда мы пишем:

enum open_modes{ input = 1, output, append };

мы определяем новый тип open_modes. Допустимые значения для объекта этого типа ограничены набором 1, 2 и 3, причем каждое из указанных значений имеет мнемоническое имя. Мы можем использовать имя этого нового типа для определения как объекта данного типа, так и типа формальных параметров функции:

void open_file( string file_name, open_modes om );

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

open_file( "Phoenix and the Crane", append );

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

// ошибка: 1 не является элементом перечисления open_modes

open_file( "Jonah", 1 );

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

open_modes om = input;

// ...

om = append;

open_file( "TailTell", om );

Однако получить имена таких элементов невозможно. Если мы напишем оператор вывода:

cout << input << " " << om << endl;

то все равно получим:

1 3

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

cout << open_modes_table[ input ] << " "

<< open_modes_table[ om ]    << endl

Будет выведено:

input append

Кроме того, нельзя перебрать все значения перечисления:

// не поддерживается

for ( open_modes iter = input; iter != append; ++inter )

// ...

Для определения перечисления служит ключевое слово enum, а имена элементов задаются в фигурных скобках, через запятую. По умолчанию первый из них равен 0, следующий – 1 и так далее. С помощью оператора присваивания это правило можно изменить. При этом каждый следующий элемент без явно указанного значения будет на 1 больше, чем элемент, идущий перед ним в списке. В нашем примере мы явно указали значение 1 для input, при этом output и append будут равны 2 и 3. Вот еще один пример:

// shape == 0, sphere == 1, cylinder == 2, polygon == 3

enum Forms{ share, spere, cylinder, polygon };

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

// point2d == 2, point2w == 3, point3d == 3, point3w == 4

enum Points { point2d=2, point2w, point3d=3, point3w=4 };

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

void mumble() {

   Points pt3d = point3d; // правильно: pt2d == 3

   // ошибка: pt3w инициализируется типом int

   Points pt3w = 3;

   // ошибка: polygon не входит в перечисление Points

   pt3w = polygon;

   // правильно: оба объекта типа Points

   pt3w = pt3d;

}

Однако в арифметических выражениях перечисление может быть автоматически преобразовано в тип int. Например:

const int array_size = 1024;

// правильно: pt2w преобразуется int

int chunk_size = array_size * pt2w;

3.9. Тип “массив

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

int ival;

определяет ival как переменную типа int, а инструкция

int ia[ 10 ];

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

ival = ia[ 2 ];

присваивает переменной ival значение элемента массива ia с индексом 2. Аналогично

ia[ 7 ] = ival;

присваивает элементу с индексом 7 значение ival.

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

extern int get_size();

// buf_size и max_files константы

const int buf_size = 512, max_files = 20;

int staff_size = 27;

// правильно: константа

char input_buffer[ buf_size ];

// правильно: константное выражение: 20 - 3

char *fileTable[ max_files-3 ];

// ошибка: не константа

double salaries[ staff_size ];

// ошибка: не константное выражение

int test_scores[ get_size() ];

Объекты buf_size и max_files являются константами, поэтому определения массивов input_buffer и fileTable правильны. А вот staff_size – переменная (хотя и инициализированная константой 27), значит, salaries[staff_size] недопустимо. (Компилятор не в состоянии найти значение переменной staff_size в момент определения массива salaries.)

Выражение max_files-3 может быть вычислено на этапе компиляции, следовательно, определение массива fileTable[max_files-3] синтаксически правильно.

Нумерация элементов начинается с 0, поэтому для массива из 10 элементов правильным диапазоном индексов является не 1 – 10, а 0 – 9. Вот пример перебора всех элементов массива:

int main()

{

const int array_size = 10;

int ia[ array_size ];

for ( int ix = 0; ix < array_size; ++ ix )

 ia[ ix ] = ix;

}

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

const int array_size = 3;

int ia[ array_size ] = { 0, 1, 2 };

Если мы явно указываем список значений, то можем не указывать размер массива: компилятор сам подсчитает количество элементов:

// массив размера 3

int ia[] = { 0, 1, 2 };

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

// ia ==> { 0, 1, 2, 0, 0 }

const int array_size = 5;

int ia[ array_size ] = { 0, 1, 2 };

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

const char cal[] = {'C', '+', '+' };

const char cal2[] = "C++";

Размерность массива ca1 равна 3, массива ca2 – 4 (в строковых литералах учитывается завершающий нулевой символ). Следующее определение вызовет ошибку компиляции:

// ошибка: строка "Daniel" состоит из 7 элементов

const char ch3[ 6 ] = "Daniel";

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

const int array_size = 3;

int ix, jx, kx;

// правильно: массив указателей типа int*

int *iar [] = { &ix, &jx, &kx };

// error: массивы ссылок недопустимы

int &iar[] = { ix, jx, kx };

int main()

{

int ia3{ array_size ]; // правильно

 

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

ia3 = ia;

return 0;

}

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

const int array_size = 7;

int ia1[] = { 0, 1, 2, 3, 4, 5, 6 };

int main()

{

int ia3[ array_size ];

for ( int ix = 0; ix < array_size; ++ix )

 ia2[ ix ] = ia1[ ix ];

return 0;

}

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

int someVal, get_index();

ia2[ get_index() ] = someVal;

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

Упражнение 3.22

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

(a) int ia[ buf_size ];     (d) int ia[ 2 * 7 - 14 ]

(b) int ia[ get_size() ];   (e) char st[ 11 ] = "fundamental";

(c) int ia[ 4 * 7 - 14 ];

Упражнение 3.23

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

int main() {

   const int array_size = 10;

   int ia[ array_size ];

   for ( int ix = 1; ix <= array_size; ++ix )

     ia[ ia ] = ix;

   // ...

}

3.9.1. Многомерные массивы

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

int ia[ 4 ][ 3 ];

Первая величина (4) задает количество строк, вторая (3) – количество столбцов. Объект ia определен как массив из четырех строк по три элемента в каждой. Многомерные массивы тоже могут быть инициализированы:

int ia[ 4 ][ 3 ] = {

   { 0, 1, 2 },

   { 3, 4, 5 },

   { 6, 7, 8 },

   { 9, 10, 11 }

};

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

int ia[4][3] = { 0,1,2,3,4,5,6,7,8,9,10,11 };

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

int ia[ 4 ][ 3 ] = { {0}, {3}, {6}, {9} };

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

int ia[ 4 ][ 3 ] = { 0, 3, 6, 9 };

При обращении к элементам многомерного массива необходимо использовать индексы для каждого измерения (они заключаются в квадратные скобки). Так выглядит инициализация двумерного массива с помощью вложенных циклов:

int main()

{

const int rowSize = 4;

const int colSize = 3;

int ia[ rowSize ][ colSize ];

for ( int = 0; i < rowSize; ++i )

 for ( int j = 0; j < colSize; ++j )

  ia[ i ][ j ] = i + j j;

}

Конструкция

ia[ 1, 2 ]

является допустимой с точки зрения синтаксиса С++, однако означает совсем не то, чего ждет неопытный программист. Это отнюдь не объявление двумерного массива 1 на 2. Агрегат в квадратных скобках – это список выражений через запятую, результатом которого будет последнее значение 2 (см. оператор “запятая” в разделе 4.2). Поэтому объявление ia[1,2] эквивалентно ia[2]. Это еще одна возможность допустить ошибку.

3.9.2. Взаимосвязь массивов и указателей

Если мы имеем определение массива:

int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };

то что означает простое указание его имени в программе?

ia;

Использование идентификатора массива в программе эквивалентно указанию адреса его первого элемента:

ia;

&ia[0]

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

// оба выражения возвращают первый элемент

*ia;

ia[0];

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

&ia[1];

Как мы уже упоминали раньше, выражение

ia+1;

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

*(ia+1);

ia[1];

Отметим разницу в выражениях:

*ia+1

и

*(ia+1);

Операция разыменования имеет более высокий приоритет, чем операция сложения (о приоритетах операций говорится в разделе 4.13). Поэтому первое выражение сначала разыменовывает переменную ia и получает первый элемент массива, а затем прибавляет к нему 1. Второе же выражение доставляет значение второго элемента.

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

#include <iostream>

int main()

{

int ia[9] = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };

int *pbegin = ia;

int *pend = ia + 9;

    while ( pbegin != pend ) {

      cout << *pbegin <<;

      ++pbegin;

}

Указатель pbegin инициализируется адресом первого элемента массива. Каждый проход по циклу увеличивает этот указатель на 1, что означает смещение его на следующий элемент. Как понять, где остановиться? В нашем примере мы определили второй указатель pend и инициализировали его адресом, следующим за последним элементом массива ia. Как только значение pbegin станет равным pend, мы узнаем, что массив кончился.

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

#inc1ude <iostream>

void ia_print( int *pbegin, int *pend )

{

   while ( pbegin != pend ) {

       cout << *pbegin << ' ';

       ++pbegin;

   }

}

int main()

{

   int ia[9] = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };

   ia_print( ia, ia + 9 );

}

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

#inc1ude <iostream>

template <c1ass e1emType>

void print( elemType *pbegin, elemType *pend )

{

   while ( pbegin != pend ) {

       cout << *pbegin << ' ';

       ++pbegin;

   }

}

Теперь мы можем вызывать нашу функцию print() для печати массивов любого типа:

int main()

{

   int ia[9] = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };

   double da[4] = { 3.14, 6.28, 12.56, 25.12 };

   string sa[3] = { "piglet", "eeyore", "pooh" };

   print( ia, ia+9 );

   print( da, da+4 );

   print( sa, sa+3 );

}

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

#include <a1gorithm>

int main()

{

   int ia[6] = { 107, 28, 3, 47, 104, 76 };

   string sa[3] = { "piglet", "eeyore", "pooh" };

   sort( ia, ia+6 );

   sort( sa, sa+3 );

};

(Мы подробно остановимся на обобщенных алгоритмах в главе 12; в Приложении будут приведены примеры их использования.)

В стандартной библиотеке С++ содержится набор классов, которые инкапсулируют использование контейнеров и указателей. (Об этом говорилось в разделе 2.8.) В следующем разделе мы займемся стандартным контейнерным типом vector, являющимся объектно-ориентированной реализацией массива.

3.10. Класс vector

Использование класса vector (см. раздел 2.8) является альтернативой применению встроенных массивов. Этот класс предоставляет гораздо больше возможностей, поэтому его использование предпочтительней. Однако встречаются ситуации, когда не обойтись без массивов встроенного типа. Одна из таких ситуаций – обработка передаваемых программе параметров командной строки, о чем мы будем говорить в разделе 7.8. Класс vector, как и класс string, является частью стандартной библиотеки С++.

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

#include <vector>

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

vector< int > ivec( 10 );

что аналогично определению массива встроенного типа:

int ia[ 10 ];

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

void simp1e_examp1e()

{

   const int e1em_size = 10;

   vector< int > ivec( e1em_size );

   int ia[ e1em_size ];

   for ( int ix = 0; ix < e1em_size; ++ix )

       ia[ ix ] = ivec[ ix ];

   // ...

}

Мы можем узнать размерность вектора, используя функцию size(), и проверить, пуст ли вектор, с помощью функции empty(). Например:

void print_vector( vector<int> ivec )

{

   if ( ivec.empty() )

       return;

   for ( int ix=0; ix< ivec.size(); ++ix )

       cout << ivec[ ix ] << ' ';

}

Элементы вектора инициализируются значениями по умолчанию. Для числовых типов и указателей таким значением является 0. Если в качестве элементов выступают объекты класса, то инициатор для них задается конструктором по умолчанию (см. раздел 2.3). Однако инициатор можно задать и явно, используя форму:

vector< int > ivec( 10, -1 );

Все десять элементов вектора будут равны -1.

Массив встроенного типа можно явно инициализировать списком:

int ia[ 6 ] = { -2, -1, О, 1, 2, 1024 };

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

// 6 элементов ia копируются в ivec

vector< int > ivec( ia, ia+6 );

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

// копируются 3 элемента: ia[2], ia[3], ia[4]

vector< int > ivec( &ia[ 2 ], &ia[ 5 ] );

Еще одним отличием вектора от массива встроенного типа является возможность инициализации одного объекта типа vector другим и использования операции присваивания для копирования объектов. Например:

vector< string > svec;

void init_and_assign()

{

   // один вектор инициализируется другим

   vector< string > user_names( svec );

   // ...

   // один вектор копируется в другой

   svec = user_names;

}

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

vector< string > text;

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

string word;

while ( cin >> word ) {

   text.push_back( word );

   // ...

}

Хотя мы можем использовать операцию взятия индекса для перебора элементов вектора:

cout << "считаны слова: \n";

for ( int ix =0; ix < text.size(); ++ix )

   cout << text[ ix ] << ' ';

cout << endl;

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

cout << "считаны слова: \n";

for ( vector<string>::iterator it = text.begin();

     it != text.end(); ++it )

   cout << *it << ' ';

cout << endl;

Итератор – это класс стандартной библиотеки, фактически являющийся указателем на элемент массива.

Выражение

*it;

разыменовывает итератор и дает сам элемент вектора. Инструкция

++it;

сдвигает указатель на следующий элемент. Не нужно смешивать эти два подхода. Если следовать идиоме STL при определении пустого вектора:

vector<int> ivec;

будет ошибкой написать:

ivec[0] = 1024;

У нас еще нет ни одного элемента вектора ivec; количество элементов выясняется с помощью функции size().

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

vector<int> ia( 10 );

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

const int size = 7;

int ia[ size ] = { 0, 1, 1, 2, 3, 5, 8 };

vector< int > ivec( size );

for ( int ix = 0; ix < size; ++ix )

   ivec.push_back( ia[ ix ] );

Имелась в виду инициализация вектора ivec значениями элементов ia, вместо чего получился вектор ivec размера 14.

Следуя идиоме STL, можно не только добавлять, но и удалять элементы вектора. (Все это мы рассмотрим подробно и с примерами в главе 6.)

Упражнение 3.24

Имеются ли ошибки в следующих определениях?

int ia[ 7 ] = { 0, 1, 1, 2, 3, 5, 8 };

(a) vector< vector< int > > ivec;

(b) vector< int > ivec = { 0, 1, 1, 2, 3, 5, 8 };

(c) vector< int > ivec( ia, ia+7 );

(d) vector< string > svec = ivec;

(e) vector< string > svec( 10, string( "null" ));

Упражнение 3.25

Реализуйте следующую функцию:

bool is_equa1( const int*ia, int ia_size,

              const vector<int> &ivec );

Функция is_equal() сравнивает поэлементно два контейнера. В случае разного размера контейнеров “хвост” более длинного в расчет не принимается. Понятно, что, если все сравниваемые элементы равны, функция возвращает true, если отличается хотя бы один – false. Используйте итератор для перебора элементов. Напишите функцию main(), обращающуюся к is_equal().

3.11. Класс complex

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

#include <comp1ex>

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

2 + 3i

где 2 – действительная часть, а 3i – мнимая. Вот примеры определений объектов типа complex:

// чисто мнимое число: 0 + 7-i

comp1ex< double > purei( 0, 7 );

// мнимая часть равна 0: 3 + Oi

comp1ex< float > rea1_num( 3 );

// и вещественная, и мнимая часть равны 0: 0 + 0-i

comp1ex< long double > zero;

// инициализация одного комплексного числа другим

comp1ex< double > purei2( purei );

Поскольку complex, как и vector, является шаблоном, мы можем конкретизировать его типами float, double и long double, как в приведенных примерах. Можно также определить массив элементов типа complex:

complex< double > conjugate[ 2 ] = {

   complex< double >( 2, 3 ),

   complex< double >( 2, -3 )

};

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

complex< double > *ptr = &conjugate[0];

complex< double > &ref = *ptr;

Комплексные числа можно складывать, вычитать, умножать, делить, сравнивать, получать значения вещественной и мнимой части. (Более подробно мы будем говорить о классе complex в разделе 4.6.)

3.12. Директива typedef

Директива typedef позволяет задать синоним для встроенного либо пользовательского типа данных. Например:

typedef double      wages;

typedef vector<int> vec_int;

typedef vec_int     test_scores;

typedef bool        in_attendance;

typedef int         *Pint;

Имена, определенные с помощью директивы typedef, можно использовать точно так же, как спецификаторы типов:

// double hourly, weekly;

wages hourly, weekly;

// vector<int> vecl( 10 );

vec_int vecl( 10 );

// vector<int> test0( c1ass_size );

const int c1ass_size = 34;

test_scores test0( c1ass_size );

// vector< bool > attendance;

vector< in_attendance > attendance( c1ass_size );

// int *table[ 10 ];

Pint table [ 10 ];

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

Для чего используются имена, определенные с помощью директивы typedef? Применяя мнемонические имена для типов данных, можно сделать программу более легкой для восприятия. Кроме того, принято употреблять такие имена для сложных составных типов, в противном случае воспринимаемых с трудом (см. пример в разделе 3.14), для объявления указателей на функции и функции-члены класса (см. раздел 13.6).

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

typedef char *cstring;

Каков тип переменной cstr в следующем объявлении:

extern const cstring cstr;

Ответ, который кажется очевидным:

const char *cstr

Однако это неверно. Спецификатор const относится к cstr, поэтому правильный ответ – константный указатель на char:

char *const cstr;

3.13. Спецификатор volatile

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

Спецификатор volatile используется подобно спецификатору const:

volatile int disp1ay_register;

volatile Task *curr_task;

volatile int ixa[ max_size ];

volatile Screen bitmap_buf;

display_register – неустойчивый объект типа int. curr_task – указатель на неустойчивый объект класса Task. ixa – неустойчивый массив целых, причем каждый элемент такого массива считается неустойчивым. bitmap_buf – неустойчивый объект класса Screen, каждый его член данных также считается неустойчивым.

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

3.14. Класс pair

Класс pair (пара) стандартной библиотеки С++ позволяет нам определить одним объектом пару значений, если между ними есть какая-либо семантическая связь. Эти значения могут быть одинакового или разного типа. Для использования данного класса необходимо включить заголовочный файл:

#inc1ude <uti1ity>

Например, инструкция

pair< string, string > author( "James", "Joyce" );

создает объект author типа pair, состоящий из двух строковых значений.

Отдельные части пары могут быть получены с помощью членов first и second:

string firstBook;

if ( Joyce.first == "James" &&

    Joyce.second == "Joyce" )

 firstBook = "Stephen Hero";

Если нужно определить несколько однотипных объектов этого класса, удобно использовать директиву typedef:

typedef pair< string, string > Authors;

Authors proust( "marcel", "proust" );

Authors joyce( "James", "Joyce" );

Authors musil( "robert", "musi1" );

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

class EntrySlot;

extern EntrySlot* 1ook_up( string );

typedef pair< string, EntrySlot* > SymbolEntry;

SymbolEntry current_entry( "author", 1ook_up( "author" ));

// ...

if ( EntrySlot *it = 1ook_up( "editor" ))

{

   current_entry.first = "editor";

   current_entry.second = it;

}

(Мы вернемся к рассмотрению класса pair в разговоре о контейнерных типах в главе 6 и об обобщенных алгоритмах в главе 12.)

3.15. Типы классов

Механизм классов позволяет создавать новые типы данных; с его помощью введены типы string, vector, complex и pair, рассмотренные выше. В главе 2 мы рассказывали о концепциях и механизмах, поддерживающих объектный и объектно-ориентированный подход, на примере реализации класса Array. Здесь мы, основываясь на объектном подходе, создадим простой класс String, реализация которого поможет понять, в частности, перегрузку операций – мы говорили о ней в разделе 2.3. (Классы подробно рассматриваются в главах 13, 14 и 15. Мы дали краткое описание класса для того, чтобы приводить более интересные примеры. Читатель, только начинающий изучение С++, может пропустить этот раздел и подождать более систематического описания классов в следующих главах.)

Наш класс String должен поддерживать инициализацию объектом класса String, строковым литералом и встроенным строковым типом, равно как и операцию присваивания ему значений этих типов. Мы используем для этого конструкторы класса и перегруженную операцию присваивания. Доступ к отдельным символам String будет реализован как перегруженная операция взятия индекса. Кроме того, нам понадобятся: функция size() для получения информации о длине строки; операция сравнения объектов типа String и объекта String со строкой встроенного типа; а также операции ввода/вывода нашего объекта. В заключение мы реализуем возможность доступа к внутреннему представлению нашей строки в виде строки встроенного типа.

Определение класса начинается ключевым словом class, за которым следует идентификатор – имя класса, или типа. В общем случае класс состоит из секций, предваряемых словами public (открытая) и private (закрытая). Открытая секция, как правило, содержит набор операций, поддерживаемых классом и называемых методами или функциями-членами класса. Эти функции-члены определяют открытый интерфейс класса, другими словами, набор действий, которые можно совершать с объектами данного класса. В закрытую секцию обычно включают данные-члены, обеспечивающие внутреннюю реализацию. В нашем случае к внутренним членам относятся _string – указатель на char, а также _size типа int. _size будет хранить информацию о длине строки, а _string – динамически выделенный массив символов. Вот как выглядит определение класса:

#inc1ude <iostream>

class String;

istream& operator>>( istream&, String& );

ostream& operator<<( ostream&, const String& );

class String {

public:

 // набор конструкторов

 // для автоматической инициализации

 // String strl;              // String()

 // String str2( "literal" ); // String( const char* );

 // String str3( str2 );      // String( const String& );

 String();

 String( const char* );

 String( const String& );

 // деструктор

 ~String();

 // операторы присваивания

 // strl = str2

 // str3 = "a string literal"

 String& operator=( const String& );

 String& operator=( const char* );

 // операторы проверки на равенство

 // strl == str2;

 // str3 == "a string literal";

 bool operator==( const String& );

 bool operator==( const char* );

 // перегрузка оператора доступа по индексу

 // strl[ 0 ] = str2[ 0 ];

 char& operator[]( int );

 // доступ к членам класса

 int   size() { return _size; }

 char* c_str() { return _string; }

private:

 int  _size;

 char *_string;

}

Класс String имеет три конструктора. Как было сказано в разделе 2.3, механизм перегрузки позволяет определять несколько реализаций функций с одним именем, если все они различаются количеством и/или типами своих параметров. Первый конструктор

String();

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

String str1;

для str1 вызывается такой конструктор.

Два оставшихся конструктора имеют по одному параметру. Так, для

String str2("строка символов");

вызывается конструктор