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

Бьерн Страуструп.
Язык программирования С++ 
 
322 
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 контролируется 

Бьерн Страуструп.
Язык программирования С++ 
 
323 
// функцией присваивания 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 }; 
Как только мы остановимся на одном из решений, определится объем изменений, которые придется 
внести в систему. Допустим, в этом примере нам потребуется ввести свитки третьего вида. Вначале 
предполагалось, что могут быть свитки только двух видов (ведь всякое окно имеет только два 
измерения), но в этом примере, как и во многих других, возможны расширения, которые возникают как 
вопросы перепроектирования. Например, может появиться желание использовать "управляющую 
кнопку" (типа мыши) вместо свитков двух видов. Такая кнопка задавала бы прокрутку в различных 
направлениях в зависимости от того, в какой части окна нажал ее пользователь. Нажатие в середине 
верхней строчки должно вызывать "прокручивание вверх", нажатие в середине левого столбца - 
"прокручивание влево", нажатие в левом верхнем углу - "прокручивание вверх и влево". Такая кнопка не 
является чем-то необычным, и ее можно рассматривать как уточнение понятия свитка, которое 
особенно подходит для тех областей приложения, которые связаны не с обычными текстами, а с более 
сложной информацией. 
Для добавления управляющей кнопки к программе, использующей иерархию из трех свитков, требуется 
добавить еще один класс, но не нужно менять программу, работающую со старыми свитками:
свиток 
горизонтальный_свиток
вертикальный_свиток
управляющая_кнопка 
Это положительная сторона "иерархического решения".
Задание ориентации свитка в качестве параметра приводит к заданию полей типа в объектах свитка и 
использованию переключателей в теле функций-членов свитка. Иными словами, перед нами обычная 
дилемма: выразить данный аспект структуры системы с помощью определений или реализовать его в 
операторной части программы. Первое решение увеличивает объем статических проверок и объем 
информации, над которой могут работать разные вспомогательные средства. Второе решение 

Бьерн Страуструп.
Язык программирования С++ 
 
324 
откладывает проверки на стадию выполнения и разрешает менять тела отдельных функций, не изменяя 
общую структуру системы, какой она представляется с точки зрения статического контроля или 
вспомогательных средств. В большинстве случаев, предпочтительнее первое решение. 
Положительной стороной решения с единым типом свитка является то, что легко передавать 
информацию о виде нужного нам свитка другой функции: 
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; 
} 

жүктеу/скачать 2,87 Mb.

Достарыңызбен бөлісу: