virtual void Process(View* v) = 0;

class MouseClick : public Event { public:

virtual void Process(View* v) { v->Process(*this); }

class View { Чисто виртуальный базовый класс для видов public:

virtual void Process(MouseClick& ev) = 0; virtual void Process(Keystroke& ev) = 0; И т.д.

Хотя на первый взгляд кажется, что проблема отличается от иерархии Number, присмотритесь повнимательнее. Реализация функции Process() класса Event всего лишь разворачивает операцию и перенаправляет вызов. Поскольку функция Event::Process() является виртуальной, когда дело доходит до класса View, точный тип Event уже известен, и компилятор вызывает правильную перегруженную версию View::Process() .

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

Передача более высокого порядка

До сих пор мы рассматривали только бинарные функции, однако та же методика распространяется на функции с производным количеством аргументов неизвестного типа. Если функция имеет n аргументов, передавать придется n раз. Предположим, у вас имеется функция, которая получает три аргумента Number и возвращает Number&. Можно устроить, чтобы первый аргумент оказался в левой части оператора -> (или .), а дальше начинаются комбинаторные игры.

class Number { protected:

this - неявный второй аргумент

virtual Number& fn1(Integer& n1, Number& n3) = 0;

virtual Number& fn1(Comp1ex& n1, Number& n3) = 0;

И т.д. для всех типов в первой позиции

this - неявный третий аргумент virtual Number& fn2(Integer& n1, Integer& n2) = 0; virtual Number& fn2(Integer& n1, Comp1ex& n2) = 0; virtual Number& fn2(Comp1ex& n1, Integer& n2) = 0; virtual Number& fn2(Comp1ex& n1, Comp1ex& n2) = 0; И т.д. для всех сочетаний public:

this - неявный первый аргумент

virtual Number& fn(Number& n2, Number& n3) = 0;

class Integer : public Number { protected:

this - неявный второй аргумент

virtual Number& fn1(Integer& n1, Number& n3) { return n3.fn2(n1, *this); }

virtual Number& fn1(Comp1ex& n1, Number& n3)

{ reutrn n3.fn2(n1, *this); } И т.д. для всех типов в первой позиции

this - неявный третий аргумент

virtual Number& fn2(Integer& n1, Integer& n2)

Настоящая реализация - известны все три аргумента

И т.д. для всех сочетаний public:

this - заданный первый аргумент virtual Number& fn(Number& n2, Number& n3) { return n2.fn1(*this, n3); }

Такой вариант, как и двойная передача, обычно работает быстрее других предлагаемых архитектур. Все делается за три элементарных переходя через v-таблицы, а это намного быстрее, чем хеширование и просмотр таблиц. Однако он некрасив и быстро становится неуправляемым. Возьмите решение с двойной передачей и вообразите, что его сложность начинает возрастать по экспоненте; вы получите некоторое представление о том, с чем связано поддержание такой структуры.

Описанная методика применима и к гетероморфным иерархиям, хотя в результате у вас получится программа-кузнечик : она совершает головокружительные прыжки из стороны в сторону. Если вы проделаете нечто подобное в нетривиальной ситуации, в день сдачи программы прихватите пончиков или коробку конфет и будьте необычайно любезны со своими коллегами. Даже если это оптимальное решение, его наверняка сочтут как бы это сказать в лучшем случае, спорным.

Если функция имеет больше двух аргументов, число сочетаний растет быстрее, чем грибы после дождя. Организуя множественную передачу для нескольких аргументов, серьезно подумайте над описанными ниже приемами группировки, уменьшающими количество сочетаний.

Группировка передач и преобразования

В реальной жизни редко встречаются уникальные реализации для всех сочетаний левого и правого операндов. Например, в любой операции с участием комплексного и какого-то другог числа результат будет комплексным. Преобразование некомплексного аргумента в комплексный сокращает количество диспетчерских функций. Процесс сокращения матрицы передач я описываю общим термином группировка (clustering). На самом деле для большинства задач не существует элегантного, универсального и притом головокружительно быстрого способа группировки. К тому же эти способы практически никак не связаны с синтаксисом или идиомами С++. Они либо требуют знания типов (тема, к которой мы вернемся в следующей главе), либо основаны на логике if/then/else или switch/case, которой мы пытаемся всячески избегать в этой части.

Существут два основных подхода:

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

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

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

Первый подход обычно связан с созданием специфической иерархии классов, которая отображает структуру групп. При этом диспетчерские функции поддерживаются только на высоких уровнях иерархии классов. При поиске сигнатур компилятор автоматически преобразует производные классы к промежуточным базовым классам. Такой вариант хорошо подходит лишь для не очень глубоких

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

class foo { ... };

class bar : public foo { ... };

class banana : public bar { ... };

void fn(bar&);

void fn(foo&);

fn(*(new banana)); Неоднозначность! Ха-ха-ха!

Компиляторы обожают подобные шутки, поскольку они могут ждать и не сообщать об ошибке до тех пор, пока им не встретится заветное сочетание типов. Если бы существовала перегрузка fn() для аргумента banana&, никаких проблем не возникло бы - компилятор всегда предпочитает точное совпадение преобразованию. Но тогда пропадает весь смысл группировки посредством автоматического преобразования к базовому классу.

Отделение типов от иерархии классов

Второй подход сопровождается мучительными логическими построениями. Перед выполнением передачи аргументы преобразуются от специализированных типов к более универсальным. Например, при любой операции, в которой учавствует комплексное число (Complex), второй аргумент заранее преобразуется к типу Complex. Тем самым из матрицы фактически исключается целая строка и столбец. Если ни один из аргументов не является комплексным, мы ищем среди них вещественный (Real); если он будет найден, второй аргумент также преобразуется в Real. Если не будут найдены ни Complex, ни Real, ищем Rational и т.д. Подобная иерархия преобразований - от Integer (или чего угодно) к Rational, затем Real и Complex - не совпадает с иерархией классов, поскольку было бы глупо порождать легкий Integer от тяжеловесного Complex. Кстати, весьма интересный вопрос: почему иерархии типов (в данном случае числовых) часто плохо укладываются в иерархии классов, основанных на общих свойствах?

Это еще не все

Конечно, только что описанная методика передачи имеет некоторые недостатки. Во-первых, производные классы не удается нормально инкапсулировать, поскольку их все приходится перечислять в интерфейсах диспетчерских функций базового класса. В сущности, чтобы не вводить код типа, видимый широкой публике, мы выставили на всеобщее обозрение все производные типы - не очень хороший компромисс. Во-вторых, что произойдет с оператором вроде +=? Если в программе встречается Integer+=Comp1ex, результат будет иметь тип Complex, а мы пока не располагаем средствами для преобразования типа на месте .

В главах 11 и 12 обе проблемы будут решены для гомоморфных иерархий классов, хотя приведенные методики обобщаются и для других ситуаций (скажем, для упомянутой выше проблемы с классами Event/View). А пока лишь скажу, что описанные в этой главе приемы приносят непосредственную пользу в тех ситуациях, когда на первое место выходит быстродействие, а не инкапсуляция. Два перехода по v-таблицам почти всегда работают быстрее традиционных подходов.

Наконец, не удивляло ли вас то, как наши функции возвращали Number&? Number& Integer::operator+(const Integer& n)

Ниже приведен псевдокод if (i + n.i слишком велико для int) { return ЦелоеСПовышенной точностью

else return Integer(i + n.i);

Возвращение ссылок на переменную величину - дело опасное. Многие компиляторы пускают в расход возвращаемую величину до того, как вам удастся ее использовать. Выделение памяти под