166

{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.Сформировать иерархию преобразований и преобразовать один или оба аргумента к более универсальному типу, после чего выполнить передачу.

Их нетрудно спутать, но на самом деле они отличаются.

Группировка в базовых классах

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

167

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

class foo { ... };

class bar : public foo { ... }; class banana : public bar { ... };

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

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

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

Это еще не все

Конечно, только что описанная методика передачи имеет некоторые недостатки. Во-первых, производные классы не удается нормально инкапсулировать, поскольку их все приходится перечислять в интерфейсах диспетчерских функций базового класса. В сущности, чтобы не вводить код типа, видимый широкой публике, мы выставили на всеобщее обозрение все производные типы — не очень хороший компромисс. Во-вторых, что произойдет с оператором вроде +=? Если в программе встречается Integer+=Complex, результат будет иметь тип 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);

}

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

168

возвращаемый объект оператором new (вместо стека) решает проблему, поскольку величина заведомо остается жить после завершения функции. Но тогда возникают проблемы с управлением памятью — когда и как удалять возвращаемую величину? Чтобы решить ее, нам понадобится материал глав 11 и 12, а также одна из методик управления памятью (скажем, подсчет ссылок), рассматриваемых в последней части книги.

Итак, приведенной в этой главе информации хватит для решения простых проблем (например, связанных с событиями и видами), но она лишь закладывает основу для построения более общих решений.