Шаг 14 - Двойная диспетчеризация. Продолжение.
В Шаге 4 мы говорили о двойной диспетчеризации. Она очень хорошо подходит при необходимости отображения одних объектов посредством других, но не только; она в общем применима, когда Вам нужно обрабатывать попарные (и более) взаимодействия объектов двух и более разных классов. Получается этакая табличка, на осях которой нарисованы классы, а в ячейках - функции их взаимодействия. Количество функций равно произведению столбцов и строк этой таблички. А если диспетчеризация тройная или выше? Тогда еще умножаем на количество слоев, и дальше и дальше…
Как бы упростить жизнь? А вот так - если взаимодействие двух объектов дает один результат, пусть этим и занимается одна функция. Попробуем перевести на человеческий язык:
Пусть есть класс CTitanic и класс CIceberg. Их карма в том, чтобы столкнуться. Четыре варианта взаимодействия: Столкновение двух Ctitanic не ведет ни к чему, если вообще возможно, двух CIceberg - у них там свои дела, столкновение CTitanic и CIceberg, как известно, к семи Оскарам, и столкновение CIceberg и CTitanic - к тому же самому. То есть функций всего три. Определим взаимодействие этих классов как функцию hit(). Вот код:
#include ‹iostream.h›
// Форвардные объявления
class CTitanic;
class CIceberg;
class CFloating;
// Абстрактный базовый класс
class CFloating {
public:
virtual void hit(CIceberg&)=0;
virtual void hit(CTitanic&)=0;
public:
virtual void hit(CFloating&)=0;
};
// Класс айсберга
class CIceberg {
public:
virtual void hit(CIceberg&);
virtual void hit(CTitanic&);
public:
virtual void hit(CFloating&);
};
// Первая диспетчерская функция
void CIceberg::hit(CFloating& _co) {
_co.hit(*this);
}
// Две реализации взаимодействия
void CIceberg::hit(CIceberg& _ci) {
cout ‹‹ "ci+ci" ‹‹ endl;
}
void CIceberg::hit(CTitanic& _ct) {
cout ‹‹ "ci+co" ‹‹ endl;
}
// Класс Титаника
class CTitanic {
public:
virtual void hit(CIceberg&);
virtual void hit(CTitanic&);
public:
virtual void hit(CFloating&);
};
// Еще одна диспетчерская функция
void CTitanic::hit(CFloating& _co) { _co.hit(*this); }
// А вот эта функция могла бы быть реализацией
// но мы ее тоже делаем диспетчерской;
// в этом фрагменте диспетчеризация тройная.
void CTitanic::hit(CIceberg& _ci) {
// cout ‹‹ "co+ci" ‹‹ endl; Это могла быть реализация
_ci.hit(*this);
}
void CTitanic::hit(CTitanic& _ct) {
cout ‹‹ "co+co" ‹‹ endl;
}
// проверим по быстрому, как работает
int main () {
CIceberg i1;
CTitanic t1;
CIceberg i2;
CTitanic t2;
i1.hit(t1);
i1.hit(i2);
t1.hit(i1);
t1.hit(t2);
return 0;
}
Пояснения по коду: взаимодействующие классы надобно определить от одного общего предка, коли они уж плавают и могут друг об друга биться, так и запишем - все варианты взаимодействия должны быть чистыми виртуальными функциями.
В общем, количество действительных реализаций функций уменьшается как раз на количество совпадающих. Не так уж и плохо.
Есть еще способы уменьшить их количество, основанные на преобразованиях классов - неявных или через конструкторы. Я правда не знаю, что раньше может запутать - количество диспетчерских функций или неявные преобразования; тут, пожалуй, можно только порадоваться появлению в стандарте ограничивающего модификатора explicit, который подавляет неявные вызовы конструкторов.
Увы, двойная диспетчеризация в C++ всегда громоздкая и неудобная вещь, и вряд ли будет другой. Если мы добавляем новые классы в диспетчеризацию, приходится переписывать ранее написанные классы; все классы имеют доступ к функциям друг друга или функции должны быть открытыми.
Это - плата за отсутствие в C++ функций, виртуальных по отношению к 2 и более классам.
Шаг 15 - Как сделать массив из чего угодно.
Массивы и оператор operator[].
Давайте попробуем придумать класс, объекты которого вели бы себя как массивы? Поехали. Решим, что класс внутри себя должен иметь для простоты массив, ну там счетчик элементов… вроде больше нечему там быть. Ну раз так, то возьмем стек из Шага 13, для чистоты эксперимента выкинем спорные перегрузки operator+, operator+= и operator-, а для доступа к элементу пишем функцию int getat (int). Но что получается? Значит, добавление-изъятие мы пишем как функции только ради чистоты стиля, а других мотивов нет? А с доступом к элементу нам вообще ничего не мешает - пусть вместо getat() будет operator[](), а возвращает ссылку - ссылке же можно присвоить значение, а значит, работать будет в обе стороны, и на чтение и на запись!
class CArray {
private:
int a[100];
int iTop;
public:
// Тут смотреть нечего, конструкторы да присваивания, банально
CArray ():iTop(0) {}
CArray (const CArray& _ca) {
iTop = _ca.iTop;
for (int i=0; i++; i ‹100) a[i]= _ca.a[i];
}
CArray& operator=(const CArray& _ca) {
if (this==&_ca) return *this;
for (int i=0; i++; i ‹100) a[i]= _ca.a[i];
iTop = _ca.iTop;
return *this;
}
CArray& add (int _i) {a[iTop]=_i; iTop++; return *this;}
int pop(void) {iTop-; return a[iTop+1];}
// Две функции доступа к элементам массива
int& getat (int _i){return a[_i];}
int& operator[](int _i){return a[_i];}
};
// проверим наши рассуждения
CArray c;
int main() {
c.add(1);
c.add(2);
c.add(3);
c.add(4);
c.add(5);
c.getat(3) = 10;
c[2]=20;
return 1;
}
Разумеется, я пропустил ВСЕ детали, и важные и мелкие, но это не главное. Самое главное - последние две функции декларации.
Надеюсь, Вы понимаете значение сделанного? Вы снова Властелин. Allmighty God. А как же? Вы полностью контролируете все и всех. Как назвать того, кто издает законы, по которым живут все без исключения? Творения которого рождаются и умирают лишь по воле его? Нарушившего закон его постигает немедленная и неотвратимая кара? (Да-да, именно, как у Буча там: "сервер, не выполняющий… инварианты Господа нашего…" ой нет, не было такого, но он имел в виду!)
Практически Вы можете проверять значение индекса не меньше 0 и не больше iTop. Можете вместо массива положить указатель на массив int** a, тогда в operator[] возвращать нужно не int& а int*& - а вести себя будет точно так же. Можете вообще читать с диска или с бараньей лопатки. Более того (и это кстати очень важно) перегрузить operator[] не только для int но и чего угодно другого: для строки, float и всего остального, и не один раз. Есть ограничение правда - аргумент может быть только один. Ха, смешные потуги жалкого компилятора, нас уже не остановить:
// Это класс, объединяющий пару аргументов
class pair {
public:
int x; int y;
pair(int _x=0, int _y=0):x(_x), y(_y)р {}
};
// Перегруженный operator[]
int& operator[](pair);
//использование.
OurArray[pair(1,2)].OurFunction();
Тормознем немного. Королева в восхищении, но… есть немного проблем.
Шаг 16 - Как сделать массив из чего угодно. Продолжение.
In spring, when woods are getting green,
I'll try and tell You what I mean.
L.Carroll. Through the looking glass.
Проблема собственно в том, что ради такой простой структуры нечего и сыр-бор разводить. Если нам нужен просто массив, можно просто взять его шаблон из STL или MFC. Клянусь, это будет замечательное решение, у Вас будет огромный набор возможностей, да к тому же реализованных компактно и эффективно (в меру); если у Вас нет отклонений в психике, и Вы не порываетесь ежедневно вставить ассемблерный код в прогу на VB, этого будет достаточно. Увы, иногда нужно больше.
Ну, положим, Вам необходимо работать с геологической картой. Размер 1000х1000. Пять слоев. Если решать в лоб, то только для хранения и обработки геологических условий нужно иметь пять миллионов элементов. Совершенно ясно, всем и каждому, что создавать карту на основе простого массива абсолютно недопустимо. По видимому, объект карты должен хранить информацию только в ключевых точках, а значения между ними вычислять; при необходимости записи в карту следует проверять - есть ли такая точка во внутренней структуре, и если есть - записывать в нее, а если нет - создавать ее.
