Самомодификация и переходимость
Невидимый ведущий указатель, как и любой умный указатель, может интерпретироваться как
переходный тип. Если просто заменить указываемый объект каким-нибудь производным классом, вы фактически изменяете тип всей видимой клиенту комбинации. На этом основано решение проблемы оператора +=, которая требует самомодификации левого операнда, а также возможного оперативного изменения типа «на ходу». Если правый операнд Complex складывается с левым операндом Integer, тип левого операнда приходится менять.
// В файле number.h
class NBase; // Клиентам об этом ничего знать не нужно
class Number {
protected:
Number(const Number&) {}
Number() {}
public:
virtual NBase& AddTo(const NBase&) = 0;
virtual Number& operator+(const Number&) = 0;
// И т.д.
};
// В файле number.cpp
class Integer;
class Real;
class PNumber : public Number {
private:
NBase* number;
protected:
virtual NBase& AddTo(const NBase& n) const
{ return number->AddTo(n); } // #2
public:
PNumber(NBase* n) : number(n) {}
virtual Number& operator+(const Number& n) const
{
number = &(n.AddTo(*number)); // #1 - замена
return *this;
}
};
class NBase : public Number {
// Промежуточный базовый класс
// Традиционная двойная передача в NBase
public:
virtual NBase& operator+=(const Integer&) const = 0;
virtual NBase& operator+=(const Real&) const = 0;
// И т.д.
virtual NBase& AddTo(const NBase&) const = 0;
virtual Number& operator+(const Number& n) const
{ return Integer(0); } // Заглушка не вызывается
};
class Integer : public NBase {
private:
int value;
protected:
virtual NBase& operator+=(const Integer& i) const
{
if (value + i.value достаточно мало) {
value += i.value;
return *this;
}
else {
ArbitraryPrecisionInteger api(value);
api += i.value;
delete this;
return api;
}
public:
Integer(int i) : value(i) {}
virtual NBase& AddTo(const NBase& n) const
{ return n + *this; } // #3
};
class Real : public NBase { ... };
Все как и раньше, разве что операторы + превратились в +=, а двойная передача теперь проходит через +=(левый, правый) и AddTo(правый, левый), чтобы мы могли различать два порядка аргументов.
Это важно, поскольку в конечном счете мы хотим заменить указываемый объект левого операнда новым. Это происходит в двух местах:
1. Операторная функция PNumber::operator+=(const Number&) автоматически заменяет
число полученным новым значением.
2. Операторная функция Integer::operator+=(const Integer&) возвращает управление,
если ей не приходится изменять тип; в противном случае после удаления своего объекта она
возвращает новый объект другого типа.
По вполне понятным причинам я назову вторую из этих функций заменяющей. Заменяющие функции обладают одной экзотической (если не выразиться сильнее) особенностью: нельзя рассчитывать, что адрес объекта перед вызовом остается действительным и после вызова. Разумеется, пользоваться этим обстоятельством можно лишь в том случае, если эту логику удастся запрятать в самую глубокую и темную дыру, чтобы никто в нее не сунулся, но если это удается сделать, хлопотные алгоритмы невероятно упрощаются.
Показанный пример надежно работает, пока PNumber действует как ведущий указатель и пока можно гарантировать, что ни один объект, производный от NBase, не будет существовать без ссылающегося на него PNumber. В нашем случае, когда все прячется в файле .cpp, дело обстоит именно так.
Для такой простой проблемы программа получилась довольно большой. Я не утверждаю, что ваши хлопоты оправдаются во всех проектах. Мое решение в основном предназначено для ситуаций, в которых вы тратите много времени на разработку иерархии классов многократного использования и можете позволить себе потратить время на повышение модульности. Я привел его, поскольку оно соответствует основной идее книги - выжать из С++ все возможное и невозможное и щедро разбросать головоломки, представляющие интерес даже для самых выдающихся экспертов.