<< Пред.           стр. 80 (из 121)           След. >>

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

 
 Requested query: untamed && daddy
 
 ( 4 ) magical but untamed. "Daddy, shush, there is no such thing,"
 
 Эти элементы можно комбинировать:
 
 fiery && bird || shyly
 
 Однако обработка производится слева направо, и все элементы имеют одинаковые приоритеты. Поэтому наш составной запрос интерпретируется как fiery bird ИЛИ shyly, а не как fiery bird ИЛИ fiery shyly:
 
 ==> fiery && bird || shyly
 
  fiery ( 1 ) lines match
  bird ( 1 ) lines match
  fiery && bird ( 1 ) lines match
  shyly ( 1 ) lines match
  fiery && bird || shyly ( 2 ) lines match
 
 Requested query: fiery && bird || shyly
 
 ( 3 ) like a fiery bird in flight. A beautiful fiery bird, he tells her,
 ( 6 ) Shyly, she asks, "I mean, Daddy, is there?"
 
 Чтобы можно было группировать части запроса, наша система должна поддерживать скобки. Например:
 
 fiery && (bird || shyly)
 
 выдает все вхождения fiery bird или fiery shyly1. Результат исполнения этого запроса приведен в начале данного раздела. Кроме того, система не должна многократно отображать одну и ту же строку.
 17.1. Определение иерархии классов
 В этой главе мы построим иерархию классов для представления запроса пользователя. Сначала реализуем каждую операцию в виде отдельного класса:
 NameQuery // Shakespeare
 NotQuery // ! Shakespeare
 OrQuery // Shakespeare || Marlowe
 AndQuery // William && Shakespeare
 В каждом классе определим функцию-член eval(), которая выполняет соответствующую операцию. К примеру, для NameQuery она возвращает вектор позиций, содержащий координаты (номера строки и колонки) начала каждого вхождения слова (см. раздел 6.8); для OrQuery строит объединение векторов позиций обоих своих операндов и т.д.
 Таким образом, запрос
 
 untamed || fiery
 
 состоит из объекта класса OrQuery, который содержит два объекта NameQuery в качестве операндов. Для простых запросов этого достаточно, но при обработке составных запросов типа
 
 Alice || Emma && Weeks
 
 возникает проблема. Данный запрос состоит из двух подзапросов: объекта OrQuery, содержащего объекты NameQuery для представления слов Alice и Emma, и объекта AndQuery. Правым операндом AndQuery является объект NameQuery для слова Weeks.
 AndQuery
  OrQuery
  NameQuery ("Alice")
  NameQuery ("Emma")
  NameQuery ("Weeks")
 Но левый операнд – это объект OrQuery, предшествующий оператору &&. На его месте мог бы быть объект NotQuery или другой объект AndQuery. Как же следует представить операнд, если он может принадлежать к типу любого из четырех классов? Эта проблема имеет две стороны:
 необходимо уметь объявлять тип операнда в классах OrQuery, AndQuery и NotQuery так, чтобы с его помощью можно было представить тип любого из четырех классов запросов;
 какое бы решение мы ни выбрали в предыдущем случае, мы должны иметь возможность вызывать соответствующий классу каждого операнда вариант функции-члена eval().
 Решение, не согласующееся с объектной ориентированностью, состоит в том, чтобы определить тип операнда как объединение и включить дискриминант, показывающий текущий тип операнда:
 // не объектно-ориентированное решение
 union op_type {
  // объединение не может содержать объекты классов с
  // ассоциированными конструкторами
  NotQuery *nq;
  OrQuery *oq;
  AndQuery *aq;
  string *word;
 };
 
 enum opTypes {
  Not_query=1, O_query, And_query, Name_query
 };
 
 class AndQuery {
 public:
  // ...
 private:
  /*
  * opTypes хранит информацию о фактических типах операндов запроса
  * op_type - это сами операнды
  */
 
  op_type _lop, _rop;
  opTypes _lop_type, _rop_type;
 };
 Хранить указатели на объекты можно и с помощью типа void*:
 class AndQuery {
 public:
  // ...
 private:
  void * _lop, _rop;
  opTypes _lop_type, _rop_type;
 };
 Нам все равно нужен дискриминант, поскольку напрямую использовать объект, адресуемый указателем типа void*, нельзя, равно как невозможно определить тип такого объекта по указателю. (Мы не рекомендуем применять описанное решение в C++, хотя в языке C это весьма распространенный подход.)
 Основной недостаток рассмотренных решений состоит в том, что ответственность за определение типа возлагается на программиста. Например, в случае решения, основанного на void*-указателях, операцию eval() для объекта AndQuery можно реализовать так:
 void
 AndQuery::
 eval()
 {
  // не объектно-ориентированный подход
  // ответственность за разрешение типа ложится на программиста
 
  // определить фактический тип левого операнда
  switch( _lop_type ) {
  case And_query:
  AndQuery *paq = static_cast(_lop);
  paq->eval();
  break;
  case Or_query:
  OrQuery *pqq = static_cast(_lop);
  poq->eval();
  break;
  case Not_query:
  NotQuery *pnotq = static_cast(_lop);
  pnotq->eval();
  break;
  case Name_query:
  AndQuery *pnmq = static_cast(_lop);
  pnmq->eval();
  break;
  }
 
  // то же для правого операнда
 }
 В результате явного управления разрешением типов увеличивается размер и сложность кода и добавление нового типа или исключение существующего при сохранении работоспособности программы затрудняется.
 Объектно-ориентированное программирование предлагает альтернативное решение, в котором работа по разрешению типов перекладывается с программиста на компилятор. Например, так выглядит код операции eval() для класса AndQuery в случае применения объектно-ориентированного подхода (eval() объявлена виртуальной):
 // объектно-ориентированное решение
 // ответственность за разрешение типов перекладывается на компилятор
 
 // примечание: теперь _lop и _rop - объекты типа класса
 // их определения будут приведены ниже
 
 void
 AndQuery::
 eval()
 {
  _lop->eval();
  _rop->eval();
 }
 Если потребуется добавить или исключить какие-либо типы, эту часть программы не придется ни переписывать, ни перекомпилировать.
 17.1.1. Объектно-ориентированное проектирование
 Из чего складывается объектно-ориентированное проектирование четырех рассмотренных выше видов запросов? Как решаются проблемы их внутреннего представления?
 С помощью наследования можно определить взаимосвязи между независимыми классами запросов. Для этого мы вводим в рассмотрение абстрактный класс Query, который будет служить для них базовым (соответственно сами эти классы будут считаться производными). Абстрактный класс можно представить себе как неполный, который становится более или менее завершенным, когда из него порождаются производные классы, – в нашем случае AndQuery, OrQuery, NotQuery и NameQuery.
 В нашем абстрактном классе Query определены данные и функции-члены, общие для всех четырех типов запроса. При порождении из Query производного класса, скажем AndQuery, мы выделяем уникальные характеристики каждого вида запроса. К примеру, NameQuery – это специальный вид Query, в котором операндом всегда является строка. Мы будем называть NameQuery производным и говорить, что Query является его базовым классом. (То же самое относится и к классам, представляющим другие типы запросов.) Производный класс наследует данные и функции-члены базового и может обращаться к ним непосредственно, как к собственным членам.
 Основное преимущество иерархии наследования в том, что мы программируем открытый интерфейс абстрактного базового класса, а не отдельных производных от него специализированных типов, что позволяет защитить наш код от последующих изменений иерархии. Например, мы определяем eval() как открытую виртуальную функцию абстрактного базового класса Query. Пользовательский код, записанный в виде:
 _rop->eval();
 экранирован от любых изменений в языке запросов. Это не только позволяет добавлять, модифицировать и удалять типы, не изменяя программы пользователя, но и освобождает автора нового вида запроса от необходимости заново реализовывать поведение или действия, общие для всех типов в иерархии. Такая гибкость достигается за счет двух характеристик механизма наследования: полиморфизма и динамического связывания.
 Когда мы говорим о полиморфизме в языке C++, то имеем в виду главным образом способность указателя или ссылки на базовый класс адресовать любой из производных от него. Если определить обычную функцию eval() следующим образом:
 // pquery может адресовать любой из классов, производных от Query
 void eval( const Query *pquery )
 {
  pquery->eval();
 }
 то мы вправе вызывать ее, передавая адрес объекта любого из четырех типов запросов:
 int main()
 {
  AndQuery aq;
  NotQuery notq;
  OrQuery *oq = new OrQuery;
  NameQuery nq( "Botticelli" );
 
  // правильно: любой производный от Query класс
  // компилятор автоматически преобразует в базовый класс
  eval( &aq );
  eval( ¬q );
  eval( oq );
  eval( &nq );
 }
 В то же время попытка передать eval() адрес объекта класса, не являющегося производным от Query, вызовет ошибку компиляции:
 int main()
 {
  string name( "Scooby-Doo" );
 
  // ошибка: тип string не является производным от Query
  eval( &name );
 }
 Внутри eval() выполнение инструкции вида
 pquery->eval();
 должно вызывать нужную виртуальную функцию-член eval() в зависимости от фактического класса объекта, адресуемого указателем pquery. В примере выше pquery последовательно адресует объекты AndQuery, NotQuery, OrQuery и NameQuery. В каждой точке вызова определяется фактический тип класса объекта и вызывается подходящий экземпляр eval().
 Механизм, с помощью которого это достигается, называется динамическим связыванием. (Мы вернемся к проектированию и использованию виртуальных функций в разделе 17.5.)
 В объектно-ориентированной парадигме программист манипулирует неизвестным экземпляром, принадлежащим к одному из ограниченного, но потенциально бесконечного множества различных типов. (Ограничено оно иерархией наследования. Теоретически, однако, ни на глубину, ни на ширину такой иерархии не накладывается никаких ограничений.) В C++ это достигается путем манипулирования объектами исключительно через указатели и ссылки на базовый класс. В объектной (не объектно-ориентированной) парадигме программист работает с экземпляром фиксированного типа, который полностью определен на этапе компиляции.
 Хотя для полиморфной манипуляции объектом требуется, чтобы доступ к нему осуществлялся с помощью указателя или ссылки, сам по себе факт их использования не обязательно приводит к полиморфизму. Рассмотрим такие объявления:
 // полиморфизма нет
 int *pi;
 
 // нет поддержанного языком полиморфизма
 void *pvi;
 
 // pquery может адресовать объект любого производного от Query класса
 Query *pquery;
 В C++ полиморфизм существует только в пределах отдельных иерархий классов. Указатели типа void* можно назвать полиморфными, но в языке их поддержка не предусмотрена. Такими указателями программист должен управлять самостоятельно, с помощью явных приведений типов и той или иной формы дискриминанта, показывающего, объект какого типа в данный момент адресуется. (Можно сказать, что это “второсортные” полиморфные объекты.)
 Язык C++ обеспечивает поддержку полиморфизма следующими способами:
 путем неявного преобразования указателя или ссылки на производный класс к указателю или ссылке на открытый базовый:
 Query *pquery = new NameQuery( "Class" );
 через механизм виртуальных функций:
 pquery->eval();
 с помощью операторов dynamic_cast и typeid (они подробно обсуждаются в разделе 19.1):
 if ( NameQuery *pnq =
  dynamic_cast< NameQuery* >( pquery )) ...
 Проблему представления запроса мы решим, определив каждый операнд в классах AndQuery, NotQuery и OrQuery как указатель на тип Query*. Например:
 class AndQuery {
 public:
  // ...
 private:
  Query *_lop;
  Query *_rop;
 };
 Теперь оба операнда могут адресовать объект любого класса, производного от абстрактного базового класса Query, без учета того, определен он уже сейчас или появится в будущем. Благодаря механизму виртуальных функций, вычисление операнда, происходящее во время выполнения программы, не зависит от фактического типа:
 _rop->eval();
 На рис. 17.1 показана иерархия наследования, состоящая из абстрактного класса Query и четырех производных от него классов. Как этот рисунок транслируется в код программы на C++?
 Query
 
 AndQuery OrQuery NotQuery NameQuery
 
 Рис. 17.1. Иерархия классов Query
 В разделе 2.4 мы рассматривали реализацию иерархии классов IntArray. Синтаксическая структура определения иерархии, изображенной на рис. 17.1, аналогична:
 class Query { ... };
 class AndQuery : public Query { ... };
 class OrQuery : public Query { ... };
 class NotQuery : public Query { ... };
 class NameQuery : public Query { ... };
 Наследование задается с помощью списка базовых классов. В случае одиночного наследования этот список имеет вид:
 : уровень-доступа базовый-класс
 где уровень-доступа – это одно из ключевых слов public, protected, private (смысл защищенного и закрытого наследования мы обсудим в разделе 18.3), а базовый-класс – имя ранее определенного класса. Например, Query является открытым базовым классом для любого из четырех классов запросов.
 Класс, встречающийся в списке базовых, должен быть предварительно определен. Следующего опережающего объявления Query недостаточно для того, чтобы он мог выступать в роли базового:
 // ошибка: Query должен быть определен
 class Query;
 class NameQuery : piblic Query { ... };
 Опережающее объявление производного класса должно включать только его имя, но не список базовых классов. Поэтому следующее опережающее объявление класса NameQuery приводит к ошибке компиляции:
 // ошибка: опережающее объявление не должно
 // включать списка базовых классов
 class NameQuery : public Query;
 Правильный вариант в данном случае выглядит так:
 // опережающее объявление как производного,
 // так и обычного класса содержит только имя класса
 class Query;
 class NameQuery;
 Главное различие между базовыми классами Query и IntArray (см. раздел 2.4) состоит в том, что Query не представляет никакого реального объекта в нашем приложении. Пользователи класса IntArray вполне могут определять и использовать объекты этого типа непосредственно. Что же касается Query, то разрешается определять лишь указатели и ссылки на него, используя их для косвенного манипулирования объектами производных классов. О Query говорят, что это абстрактный базовый класс. В противоположность этому IntArray является конкретным базовым классом. Преобладающей формой в объектно-ориентированном проектировании является определение абстрактного базового класса типа Query и одиночное открытое наследование ему.
 Упражнение 17.1
 Библиотека может выдавать на руки предметы, для каждого из которых определены специальные правила выдачи и возврата. Организуйте их в иерархию наследования:
 книга аудио-книга
 аудиокассета детская кукла
 видеокассета видеоигра для приставки SEGA
 книга с подневной оплатой видеоигра для приставки SONY
 книга на компакт-диске видеоигра для приставки Nintendo
 Упражнение 17.2
 Выберите или придумайте собственную абстракцию, содержащую семейство типов. Организуйте типы в иерархию наследования:
 (a) Форматы графических файлов (gif, tiff, jpeg, bmp и т.д.)
 (b) Геометрические примитивы (прямоугольник, круг, сфера, конус и т.д.)
 (c) Типы языка C++ (класс, функция, функция-член и т.д.)
 17.2. Идентификация членов иерархии
 В разделе 2.4 мы уже упоминали о том, что в объектном проектировании обычно есть один разработчик, который конструирует и реализует класс, и много пользователей, применяющих предоставленный открытый интерфейс. Это разделение ответственности отразилось в концепции открытого и закрытого доступа к членам класса.
 Когда используется наследование, у класса оказывается множество разработчиков. Во-первых, тот, кто предоставил реализацию базового класса (и, возможно, некоторых производных от него), а во-вторых, те, кто разрабатывал производные классы на различных уровнях иерархии. Этот род деятельности тоже относится к проектированию. Разработчик подтипа часто (хотя и не всегда) должен иметь доступ к реализации базового класса. Чтобы разрешить такой вид доступа, но все же предотвратить неограниченный доступ к деталям реализации класса, вводится дополнительный уровень доступа – protected (защищенный). Данные и функции-члены, помещенные в секцию protected некоторого класса, остаются недоступными вызывающей программе, но обращение к ним из производных классов разрешено. (Все находящееся в секции private базового класса доступно только ему, но не производным.)
 Критерии помещения того или иного члена в секцию public одинаковы как для объектного, так и для объектно-ориентированного проектирования. Меняется только точка зрения на то, следует ли объявлять член закрытым или защищенным. Член базового класса объявляется закрытым, если мы не хотим, чтобы производные классы имели к нему прямой доступ; и защищенным, если его семантика такова, что для эффективной реализации производного класса может потребоваться прямой доступ к нему. При проектировании класса, который предполагается использовать в качестве базового, надо также принимать во внимание особенности функций, зависящих от типа, – виртуальных функций в иерархии классов.
 На следующем шаге проектирования иерархии классов Query следует ответить на такие вопросы:
 Какие операции следует предоставить в открытом интерфейсе иерархии классов Query?
 Какие из них следует объявить виртуальными?
 Какие дополнительные операции могут потребоваться производным классам?
 Какие данные-члены следует объявить в нашем абстрактном базовом классе Query?
 Какие данные-члены могут потребоваться производным классам?
 К сожалению, однозначно ответить на эти вопросы невозможно. Как мы увидим, процесс объектно-ориентированного проектирования по своей природе итеративен, эволюционирующая иерархия классов требует и добавлений, и модификаций. В оставшейся части этого раздела мы будем постепенно уточнять иерархию классов Query.
 17.2.1. Определение базового класса
 Члены Query представляют:
 множество операций, поддерживаемых всеми производными от него классами запросов. Сюда входят как виртуальные операции, переопределяемые в производных классах, так и невиртуальные, разделяемые всеми производными классами (мы приведем примеры тех и других);
 множество данных-членов, общих для всех производных классов. Если вынести такие члены в абстрактный базовый класс Query, мы сможем обращаться к ним вне зависимости от того, с объектом какого производного класса мы работаем.
 Если имеется запрос вида:
 
 fiery || untamed
 
 то двумя основными операциями для него будут: нахождение строк текста, удовлетворяющих условиям запроса, и представление найденных строк пользователю. Назовем эти операции соответственно eval() и display().
 Алгоритм работы eval() свой для каждого производного класса, поэтому эту функцию следует объявить виртуальной в определении Query. Всякий производный класс должен предоставить собственную реализацию для нее. Сам же Query лишь включает ее в свой открытый интерфейс.
 Алгоритм работы функции display(), выводящей найденные строки текста, не зависит от типа производного класса. Нам необходимо лишь иметь доступ к представлению самого текста и списку строк, удовлетворяющих запросу. Вместо того чтобы дублировать реализацию алгоритма и необходимые для него данные в каждом производном классе, определим единственный наследуемый экземпляр в Query.
 Такое проектное решение позволит нам вызывать любую операцию, не зная фактического типа объекта, которым мы манипулируем:
 void
 doit( Query *pq )
 {
  // виртуальный вызов
  pq->eval();
 
  // статический вызов Query::display()
  pq->display();
 }
 Как следует представить найденные строки текста? Каждому упомянутому в запросе слову будет соответствовать вектор позиций, построенный во время поиска. Позиция – это пара (строка, колонка), в которой каждый член – это значение типа short int. Отображение слов на векторы позиций, построенное функцией build_text_map(), содержит такие векторы для каждого встречающегося в тексте слова, распознанного нашей системой. Ключами для этого отображения служат значения типа string, представляющие слова. Например, для текста
 
 Alice Emma has long flowing red hair. Her Daddy says
 when the wind blows through her hair, it looks almost alive,
 like a fiery bird in flight. A beautiful fiery bird, he tells her,
 magical but untamed. "Daddy, shush, there is no such thing,"
 she tells him, at the same time wanting him to tell her more.
 Shyly, she asks, "I mean, Daddy, is there?"
 
 приведена часть отображения для некоторых слов, встречающихся неоднократно (слово – это ключ отображения; пары значений в скобках – элементы вектора позиций; отметим, что нумерация строк и колонок начинается с нуля):
 
 bird ((2,3),(2,9))
 daddy ((0,8),(3,3),(5,5))
 fiery ((2,2),(2,8))
 hair ((0,6),(1,6))
 her ((0,7),(1,5),(2,12),(4,11))
 him ((4,2),(4,8))
 she ((4,0),(5,1))
 tell ((2,11),(4,1),(4,10))
 
 Однако такой вектор – это еще ответ на запрос. К примеру, слово fiery представлено двумя позициями, причем обе находятся в одной и той же строке.
 Нам нужно вычислить множество неповторяющихся строк, соответствующих вектору позиций. Для этого можно, например, создать вектор, в который помещаются все номера строк, представленные в векторе позиций, а затем передать его обобщенному алгоритму unique(), который удалит все дубликаты (см. алгоритм unique() в Приложении). Оставшиеся строки должны быть расположены в порядке возрастания номеров. Чтобы не оставалось никаких сомнений, к вектору строк можно применить обобщенный алгоритм sort().
 Мы выбрали другой подход – построить множество (объект set) из номеров строк в векторе позиций. Такое множество содержит по одному экземпляру каждого элемента, причем хранит их в отсортированном виде. Нам потребуется функция для преобразования вектора позиций в множество неповторяющихся номеров строк:

<< Пред.           стр. 80 (из 121)           След. >>

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