|
|
Учитывая сложность важность отношений наследования, нет ничего удивительного в том, что часто их неправильно понимают и используют сверх меры. Если класс D описан как общий производный от класса B, то часто говорят, что D есть B:
class B { /* ... */ ; class D : public B /* ... */ }; // D сорта B
Иначе это можно сформулировать так: наследование - это отношение "есть", или, более точно для классов D и B, наследование - это отношение D сорта B. В отличие от этого, если класс D содержит в качестве члена другой класс B, то говорят, что D "имеет" B:
class D { // D имеет B // ... public: B b; // ... };
Иными словами, принадлежность - это отношение "иметь" или
для классов D и B просто: D содержит B.
Имея два класса B и D, как выбирать между наследованием и
принадлежностью? Рассмотрим классы самолет и мотор.Новички обычно
спрашивают: будет ли хорошим решением сделать класс самолет
производным от класса мотор. Это плохое решение, поскольку
самолет не "есть" мотор, самолет "имеет" мотор. Следует подойти
к этому вопросу, рассмотрев, может ли самолет "иметь" два или
больше моторов. Поскольку это представляется вполне возможным
(даже если мы имеем дело с программой, в которой все самолеты
будут с одним мотором), следует использовать принадлежность, а
не наследование. Вопрос "Может ли он иметь два..?" оказывается
удивительно полезным во многих сомнительных случаях. Как всегда,
наше изложение затрагивает неуловимую сущность программирования.
Если бы все классы было так же легко представить, как самолет и
мотор, то было бы просто избежать и тривиальных ошибок типа той,
когда самолет определяется как производное от класса мотор. Однако,
такие ошибки достаточно часты, особенно у тех, кто
считает наследование еще одним механизмом для сочетания
конструкций языка программирования. Несмотря на удобство и
лаконичность записи, которую предоставляет наследование, его
надо использовать только для выражения тех отношений,
которые четко определены в проекте. Рассмотрим определения:
class B { public: virtual void f(); void g(); }; class D1 { // D1 содержит B public: B b; void f(); // не переопределяет b.f() }; void h1(D1* pd) { B* pb = pd; // ошибка: невозможно преобразование D1* в B* pb = &pd->b; pb->q(); // вызов B::q pd->q(); // ошибка: D1 не имеет член q() pd->b.q(); pb->f(); // вызов B::f (здесь D1::f не переопределяет) pd->f(); // вызов D1::f }
Обратите внимание, что в этом примере нет неявного преобразования класса к одному из его элементов, и что класс, содержащий в качестве члена другой класс, не переопределяет виртуальные функции этого члена. Здесь явное отличие от примера, приведенного ниже:
class D2 : public B { // D2 есть B public: void f(); // переопределение B::f() }; void h2(D2* pd) { B* pb = pd; // нормально: D2* неявно преобразуется в B* pb->q(); // вызов B::q pd->q(); // вызов B::q pb->f(); // вызов виртуальной функции: обращение к D2::f pd->f(); // вызов D2::f }
Удобство записи, продемонстрированное в примере с классом D2, по
сравнению с записью в примере с классом D1, является причиной, по
которой таким наследованием злоупотребляют. Но следует помнить,
что существует определенная плата за удобство записи в виде
возросшей зависимости между B и D2 (см. $$12.2.3). В частности,
легко забыть о неявном преобразовании D2 в B. Если только такие
преобразования не относятся к семантике ваших классов, следует
избегать описания производного класса в общей части. Если класс
представляет определенное понятие, а наследование используется
как отношение "есть", то такие преобразования обычно как раз то,
что нужно.
Однако, бывают такие ситуации, когда желательно
иметь наследование, но нельзя допускать преобразования. Рассмотрим
задание класса cfield (controled field - управляемое поле), который,
помимо всего прочего, дает возможность контролировать на стадии
выполнения доступ к другому классу field. На первый взгляд кажется
совершенно правильным определить класс cfield как производный от
класса field:
class cfield : public field { // ... };
Это выражает тот факт, что cfield, действительно, есть сорта field, упрощает запись функции, которая использует член части field класса cfield, и, что самое главное, позволяет в классе cfield переопределять виртуальные функции из field. Загвоздка здесь в том, что преобразование cfield* к field*, встречающееся в определении класса cfield, позволяет обойти любой контроль доступа к field:
void q(cfield* p) { *p = "asdf"; // обращение к field контролируется // функцией присваивания cfield: // p->cfield::operator=("asdf") field* q = p; // неявное преобразование cfield* в field* *q = "asdf"; // приехали! контроль обойден }
Можно было бы определить класс cfield так, чтобы field был его членом, но тогда cfield не может переопределять виртуальные функции field. Лучшим решением здесь будет использование наследования со спецификацией private (частное наследование):
class cfield : private field { /* ... */ }
С позиции проектирования, если не учитывать (иногда важные) вопросы
переопределения, частное наследование эквивалентно принадлежности.
В этом случае применяется метод, при котором класс определяется
в общей части как производный от абстрактного базового класса заданием
его интерфейса, а также определяется с помощью частного наследования от
конкретного класса, задающего реализацию ($$13.3). Поскольку
наследование, используемое как частное, является
спецификой реализации, и оно не отражается в типе производного класса,
то его иногда называют "наследованием по реализации", и оно
является контрастом для наследования в общей части, когда наследуется
интерфейс базового класса и допустимы неявные преобразования к
базовому типу. Последнее наследование иногда называют определением
подтипа или "интерфейсным наследованием".
Для дальнейшего обсуждения возможности выбора наследования
или принадлежности рассмотрим, как представить в диалоговой
графической системе свиток (область для прокручивания в ней
информации), и как привязать свиток к окну на экране. Потребуются
свитки двух видов: горизонтальные и вертикальные. Это можно
представить с помощью двух типов horizontal_scrollbar и
vertical_scrollbar или с помощью одного типа scrollbar, который
имеет аргумент, определяющий, является расположение вертикальным
или горизонтальным. Первое решение предполагает, что есть еще
третий тип, задающий просто свиток - scrollbar, и этот тип
является базовым классом для двух определенных свитков. Второе
решение предполагает дополнительный аргумент у типа scrollbar и
наличие значений, задающих вид свитка. Например, так:
enum orientation { horizontal, vertical };
Как только мы остановимся на одном из решений, определится
объем изменений, которые придется внести в систему. Допустим, в
этом примере нам потребуется ввести свитки третьего вида. Вначале
предполагалось, что могут быть свитки только двух видов (ведь
всякое окно имеет только два измерения), но в этом примере,
как и во многих других, возможны расширения, которые возникают
как вопросы перепроектирования. Например, может появиться
желание использовать "управляющую кнопку" (типа мыши) вместо свитков
двух видов. Такая кнопка задавала бы прокрутку в различных
направлениях в зависимости от того, в какой части окна нажал
ее пользователь. Нажатие в середине верхней строчки должно
вызывать "прокручивание вверх", нажатие в середине левого столбца -
"прокручивание влево", нажатие в левом верхнем углу -
"прокручивание вверх и влево". Такая кнопка не является
чем-то необычным, и ее можно рассматривать как уточнение понятия
свитка, которое особенно подходит для тех областей приложения,
которые связаны не с обычными текстами, а с более сложной
информацией.
Для добавления управляющей кнопки к программе, использующей
иерархию из трех свитков, требуется добавить еще один класс, но
не нужно менять программу, работающую со старыми свитками:
Это положительная сторона "иерархического решения".
Задание ориентации свитка в качестве параметра приводит к
заданию полей типа в объектах свитка и использованию переключателей
в теле функций-членов свитка. Иными словами, перед нами обычная
дилемма: выразить данный аспект структуры системы с помощью
определений или реализовать его в операторной части программы.
Первое решение увеличивает объем статических проверок и объем
информации, над которой могут работать разные вспомогательные
средства. Второе решение откладывает проверки на стадию выполнения
и разрешает менять тела отдельных функций, не изменяя общую
структуру системы, какой она представляется с точки зрения
статического контроля или вспомогательных средств. В большинстве
случаев, предпочтительнее первое решение.
Положительной стороной решения с единым типом свитка является то,
что легко передавать информацию о виде нужного нам свитка другой
функции:
void helper(orientation oo) { //... p = new scrollbar(oo); //... } void me() { helper(horizontal); }
Такой подход позволяет на стадии выполнения легко перенастроить свиток
на другую ориентацию. Вряд ли это очень важно в примере со свитками,
но это может оказаться существенным в похожих примерах. Суть в том,
что всегда надо делать определенный выбор, а это часто непросто.
Теперь рассмотрим как привязать свиток к окну. Если считать
window_with_scrollbar (окно_со_свитком) как нечто, что является
window и scrollbar, мы получим подобное:
class window_with_scrollbar : public window, public scrollbar { // ... };
Это позволяет любому объекту типа window_with_scrollbar выступать
и как window, и как scrollbar, но от нас требуется решение
использовать только единственный тип scrollbar.
Если, с другой стороны, считать window_with_scrollbar объектом
типа window, который имеет scrollbar, мы получим такое определение:
class window_with_scrollbar : public window { // ... scrollbar* sb; public: window_with_scrollbar(scrollbar* p, /* ... */) : window(/* ... */), sb(p) { // ... } // ... };
Здесь мы можем использовать решение со свитками трех типов. Передача самого свитка в качестве параметра позволяет окну (window) не запоминать тип его свитка. Если потребуется, чтобы объект типа window_with_scrollbar действовал как scrollbar, можно добавить операцию преобразования:
window_with_scrollbar :: operator scrollbar&() { return *sb; }
| |
|
