Бьерн Страуструп. Язык программирования С++

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())

// мой код

}

// ...

{

for (int i = 0; i

{

// ваш код

}

// ...

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

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

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

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

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

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

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

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

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

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

в один.

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

{

slist sl;

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

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

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

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

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

void my(vector&);

void your(vector&);

{

slist sl;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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