* законченный учебник и руководство по языку

Вид материала

Подобный материал:

1 ... 26 27 28 29 30 31 32 33 34

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

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

разработчик может использовать в качестве ориентиров, пока не

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

Этот свод правил приводится ниже.

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

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

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

еще раз, что эти правила не являются универсальными и не могут

заменить собой размышления.

- Нацеливайте пользователя на применение абстракции данных и

объектно-ориентированного программирования.

- Постепенно переходите на новые методы, не спешите.

- Используйте возможности С++ и методы обЪектно-ориентированного

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

_ Добейтесь соответствия стиля проекта и программы.

- Концентрируйте внимание на проектировании компонента.

_ Используйте классы для представления понятий.

- Используйте общее наследование для представления отношений "есть".

- Используйте принадлежность для представления отношений "имеет".

- Убедитесь, что отношения использования понятны, не образуют

циклов, и что число их минимально.

- Активно ищите общность среди понятий области приложения и

реализации, и возникающие в результате более общие понятия

представляйте как базовые классы.

- Определяйте интерфейс так, чтобы открывать минимальное количество

требуемой информации:

- Используйте, всюду где это можно, частные данные и функции-члены.

- Используйте описания public или protected, чтобы отличить

запросы разработчика производных классов от запросов обычных

пользователей.

- Сведите к минимуму зависимости одного интерфейса от других.

- Поддерживайте строгую типизацию интерфейсов.

- Задавайте интерфейсы в терминах типов из области приложения.

Дополнительные правила можно найти $$11.5.

* ПРОЕКТИРОВАНИЕ БИБЛИОТЕК

Проект библиотеки - это проект языка,

(фольклор фирмы Bell Laboratories)

... и наоборот.

- А. Кениг

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

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

рассматриваются конкретные типы, абстрактные типы, узловые классы,

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

понятия обширного интерфейса и структуры области приложения,

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

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

обладать библиотечные классы, а не на специфике языковых средств,

которые используются для реализации таких классов, и не на

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

13.1 Введение

Разработка библиотеки общего назначения - это гораздо более трудная

задача, чем создание обычной программы. Программа - это решение

конкретной задачи для конкретной области приложения, тогда как

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

связанных с многими областями приложения. В обычной программе

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

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

создаваемых множеством различных программ. Чем более общей и полезной

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

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

эффективности, расширяемости, переносимости, непротиворечивости,

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

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

Библиотеку можно рассматривать как специальный, интересный вариант

того, что в предыдущей главе мы называли компонентом. Каждый

совет по проектированию и сопровождению компонентов становится

предельно важным для библиотек, и, наоборот, многие методы

построения библиотек находят применение при проектировании различных

компонентов.

Было бы слишком самонадеянно указывать как следует

конструировать библиотеки. В прошлом оказались успешными несколько

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

и экспериментов. Здесь только обсуждаются некоторые важные аспекты

этой задачи и предлагаются некоторые приемы, оказавшиеся полезными

при создании библиотек. Не следует забывать, что библиотеки предназначены

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

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

всех библиотек. Действительно, нет никаких причин полагать, что методы,

оказавшиеся полезными при реализации средств параллельного

программирования для ядра многопроцессорной операционной системы,

окажутся наиболее приемлемыми при создании библиотеки, предназначенной

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

интерфейс.

Понятие класса С++ может использоваться самыми разными

способами, поэтому разнообразие стилей программирования может

привести к беспорядку. Хорошая библиотека для сведения такого

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

или, по крайней мере, несколько таких стилей. Этот подход делает

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

изучить ее и правильно использовать. Далее описываются пять

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

стороны: конкретные типы ($$13.2), абстрактные типы ($$13.3),

узловые классы ($$13.4), интерфейсные классы ($$13.8), управляющие

классы ($$13.9). Все эти виды классов относятся к области понятий,

а не являются конструкциями языка. Каждое понятие воплощается

с помощью основной конструкции - класса. В идеале надо иметь

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

которого можно построить любой полезный и разумно-определенный класс.

Идеал нами не достигнут и, возможно, недостижим вообще. Важно понять,

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

проектировании библиотеки и, если рассчитывать на общее применение,

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

В этой главе вводится понятие обширного интерфейса ($$13.6),

чтобы выделить некоторый общий случай всех этих видов классов.

С помощью него определяется понятие каркаса области приложения ($$13.7).

Здесь рассматриваются прежде всего классы, относящиеся строго к

одному из перечисленных видов, хотя, конечно, используются

классы и гибридного вида. Но использование класса гибридного вида

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

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

уклониться от выбора вида класса (слишком часто "отложим пока выбор"

означает просто нежелание думать). Неискушенным разработчикам

библиотеки лучше всего держаться подальше от классов гибридного

вида. Им можно посоветовать следовать стилю программирования той из

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

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

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

библиотеки впоследствии будет "осужден" на долгие годы использования,

документирования и сопровождения своего собственного создания.

В языке С++ используются статические типы. Однако, иногда

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

предоставляемым виртуальными функциями, получать динамическую информацию

о типах. Как это сделать, описано в $$13.5. Наконец, перед всякой

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

решения рассматриваются в $$13.10. Естественно, в этой главе невозможно

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

Поэтому можно отослать к другим местам книги, где рассмотрены

следующие вопросы: работа с ошибками и устойчивость к ошибкам ($$9.8),

использование функциональных объектов и обратных вызовов ($$10.4.2

и $$9.4.3) , использование шаблонов типа для построения классов

($$8.4).

Многие темы этой главы связаны с классами, являющимися контейнерами,

(например, массивы и списки). Конечно, такие контейнерные классы

являются шаблонами типа (как было сказано в $$1.и 4.3 $$8). Но

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

содержащие указатели на объекты типа класс. Чтобы получить настоящую

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

13.2 Конкретные типы

Такие классы как vector ($$1.4), Slist ($$8.3), date ($$5.2.2) и

complex ($$7.3) являются конкретными в том смысле, что каждый из

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

набором операций. Имеется взаимнооднозначное соответствие между

интерфейсом класса и его реализацией. Ни один из них (изначально)

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

Обычно в иерархии классов конкретные типы стоят особняком. Каждый

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

Если реализация конкретного типа удачна, то работающие с ним программы

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

в которых используется некоторая специальная версия общего понятия.

Далее, если произошло значительное изменение реализации, обычно

модифицируется и интерфейс, чтобы отразить эти изменения. Интерфейс,

по своей сути, обязан показать какие изменения оказались существенными

в данном контексте. Интерфейс более высокого уровня оставляет

больше свободы для изменения реализации, но может ухудшить

характеристики программы. Более того, хорошая реализация зависит

только от минимального числа действительно существенных классов.

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

возникающих на этапе трансляции или выполнения, и вызванных

приспособлением к другим, "сходным" классам программы.

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

удовлетворять конкретный тип:

[1] полностью отражать данное понятие и метод его реализации;

[2] с помощью подстановок и операций, полностью использующих

полезные свойства понятия и его реализации, обеспечивать

эффективность по скорости и памяти, сравнимую

с "ручными программами";

[3] иметь минимальную зависимость от других классов;

[4] быть понятным и полезным даже изолированно.

Все это должно привести к тесной связи между пользователем и

программой, реализующей конкретный тип. Если в реализации произошли

изменения, программу пользователя придется перетранслировать,

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

подстановкой, а также локальные переменные конкретного типа.

Для некоторых областей приложения конкретные типы обеспечивают

основные типы, прямо не представленные в С++, например:

комплексные числа, вектора, списки, матрицы, даты, ассоциативные

массивы, строки символов и символы, из другого (не английского)

алфавита. В мире, состоящем из конкретных понятий, на самом деле

нет такой вещи как список. Вместо этого есть множество списочных

классов, каждый из которых специализируется на представлении

какой-то версии понятия список. Существует дюжина списочных

классов, в том числе: список с односторонней связью; список с

двусторонней связью; список с односторонней связью, в котором

поле связи не принадлежит объекту; список с двусторонней связью,

в котором поля связи не принадлежат объекту; список с односторонней

связью, для которого можно просто и эффективно определить входит

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

которого можно просто и эффективно определить входит ли в него данный

объект и т.д.

Название "конкретный тип" (CDT - concrete data type, т.е.

конкретный тип данных) , было выбрано по контрасту с термином

"абстрактный тип" (ADT - abstract data type, т.е. абстрактный тип

данных). Отношения между CDT и ADT обсуждаются в $$13.3.

Существенно, что конкретные типы не предназначены для явного

выражения некоторой общности. Так, типы slist и vector можно

использовать в качестве альтернативной реализации понятия

множества, но в языке это явно не отражается. Поэтому, если

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

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

между типами slist и vector. Тогда программа записывается в

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

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

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

"естественных" для данного класса операций, например таких, как

индексация для массива и удаление элемента для списка. Эти

операции представлены в оптимальном варианте, без "неестественных"

операций типа индексации списка или удаления массива, что могло

бы вызвать путаницу. Приведем пример:

void my(slist& sl)

{

for (T* p = sl.first(); p; p = sl.next())

{

// мой код

}

// ...

}

void your(vector& v)

{

for (int i = 0; i
{

// ваш код

}

// ...

}

Существование таких "естественных" для выбранного метода реализации

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

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

возможна только для простых операций типа индексации массива или

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

эффект на скорость выполнения программы. Загвоздка здесь состоит в том,

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

как, например, два приведенных выше цикла, могут выглядеть непохожими

друг на друга, а фрагменты программы, в которых для эквивалентных

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

друга. Обычно, вообще, невозможно свести сходные фрагменты программы

в один.

Пользователь, обращающийся к некоторой функции, должен точно

указать тип объекта, с которым работает функция, например:

void user()

{

slist sl;

vector v(100);

my(sl);

your(v);

my(v); // ошибка: несоответствие типа

your(sl); // ошибка: несоответствие типа

}

Чтобы компенсировать жесткость этого требования, разработчик некоторой

полезной функции должен предоставить несколько ее версий, чтобы у

пользователя был выбор:

void my(slist&);

void my(vector&);

void your(slist&);

void your(vector&);

void user()

{

slist sl;

vector v(100);

my(sl);

your(v);

my(v); // теперь нормально: вызов my(vector&)

your(sl); // теперь нормально: вызов your(slist&)

}

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

надо написать каждую версию функций my() и your() независимо друг

от друга, что может быть хлопотно.

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

на встроенные типы. Положительной стороной этого является тесная

связь между пользователем типа и его создателем, а также между

пользователями, которые создают объекты данного типа, и пользователями,

которые пишут функции, работающие с этими объектами. Чтобы

правильно использовать конкретный тип, пользователь должен

разбираться в нем детально. Обычно не существует каких-то

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

библиотеки, и что позволило бы пользователю, рассчитывая на эти

свойства, не тратить силы на изучение отдельных классов. Такова

плата за компактность программы и эффективность ее выполнения.

Иногда это вполне разумная плата, иногда нет. Кроме того, возможен

такой случай, когда отдельный конкретный класс проще понять и

использовать, чем более общий (абстрактный) класс. Именно так

бывает с классами, представляющими хорошо известные типы данных,

такие как массивы или списки.

Тем не менее, укажем, что в идеале надо скрывать, насколько

возможно, детали реализации, пока это не ухудшает характеристики

программы. Большую помощь здесь оказывают функции-подстановки.

Если сделать открытыми переменные, являющиеся членами, с помощью описания

public, или непосредственно работать с ними с помощью функций, которые

устанавливают и получают значения этих переменных, то почти всегда

это приводит к плохому результату. Конкретные типы должны быть все-таки

настоящими типами, а не просто программной кучей с нескольким функциями,

добавленными ради удобства.

13.3 Абстрактные типы

Самый простой способ ослабить связь между пользователем класса

и его создателем, а также между программами, в которых объекты

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

понятия абстрактных базовых классов. Эти классы представляют

интерфейс со множеством реализаций одного понятия. Рассмотрим

класс set, содержащий множество объектов типа T:

class set {

public:

virtual void insert(T*) = 0;

virtual void remove(T*) = 0;

virtual int is_member(T*) = 0;

virtual T* first() = 0;

virtual T* next() = 0;

virtual ~set() { }

};

Этот класс определяет интерфейс с произвольным множеством (set),

опираясь на встроенное понятие итерации по элементам множества.

Здесь типично отсутствие конструктора и наличие виртуального

деструктора, см. также $$6.7. Рассмотрим пример:

class slist_set : public set, private slist {

slink* current_elem;

public:

void insert(T*);

void remove(T*);

int is_member(T*);

virtual T* first();

virtual T* next();

slist_set() : slist(), current_elem(0) { }

};

class vector_set : public set, private vector {

int current_index;

public:

void insert(T*);

void remove(T*);

int is_member(T*);

T* first() { current_index = 0; return next(); }

T* next();

vector_set(int initial_size)

: array(initial_size), current_index(0) { }

};

Реализация конкретного типа используется как частный базовый

класс, а не член класса. Это сделано и для удобства записи, и потому,

что некоторые конкретные типы могут иметь защищенный интерфейс

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

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

некоторые классы, которые имеют виртуальные функции и не являются

конкретными типами. Только с помощью образования производных классов

можно в новом классе изящно переопределить (подавить) виртуальную

функцию класса реализации. Интерфейс определяется абстрактным классом.

Теперь пользователь может записать свои функции из $$13.2

таким образом:

void my(set& s)

{

for (T* p = s.first(); p; p = s.next())

{

// мой код

}

// ...

}

void your(set& s)

{

for (T* p = s.first(); p; p = s.next())

{

// ваш код

}

// ...

Blog

* законченный учебник и руководство по языку