Образы автоматических объектов

Концепцию образа можно немного обобщить, чтобы она распространялась не только на объекты, созданные оператором new и обслуживаемые *-указателями, но и автоматические объекты. Автоматическими считаются стековые объекты, а также переменные и компоненты базовых классов вмещающего объекта независимо от того, выделялась память под вмещающий объект динамически или нет.

template <class Type>

class AutoImage {

private:

Type current;

Type image;

bool have_image; // Истина, если образ существует

public:

AutoImage() : have_image(false) {}

AutoImage(const AutoImage<Type>& ai)

: current(ai.current), image(), have_image(false) {}

AutoImage<Type>& operator=(const AutoImage<Type>& ip)

{

if (this != &ip) {

current = ip.current;

have_image = false;

}

return *this;

}

AutoImage<Type>& operator=(const Type& t)

{

current = t;

return *this;

}

operator Type&() { return current; }

void Snapshot()

{

image = current;

have_image = true;

}

void Commit() { have_image = false; }

void Rollback()

{

current = image;

have_image = false;

}

bool HaveImage() { return have_image; }

};

Этот шаблон работает со всеми классами, которые удовлетворяют двум условиям:

1. Тип, используемый в качестве параметра, имеет конструктор без аргументов. Он используется в конструкторе AutoImage для инициализации current и image.

2. Тип, используемый в качестве параметра, допускает присваивание с помощью оператора = по умолчанию, предоставленного компилятором, или перегруженного варианта для данного типа. Используется в функциях Shapshot() и Rollback().

Все встроенные типы (такие как int и double) удовлетворяют этим условиям. Подходят и другие классы, имеющие конструктор без аргументов и рабочий оператор =. Чем дольше я имею дело с C++, тем чаще мне кажется, что нарушение этих требований - проявление злостного непрофессионализма, за которое следует наказывать парой лет каторжного программирования на BASIC. Заодно я бы издал закон о том, чтобы конструкторы копий всегда работали так, как им положено.

Конструктор копий AutoImage следует примеру ImagePtr и ImageStackPtr - он использует

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

1. Изменить тип image с Type на Type* и выделять для него память оператором new. Это

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

2. Воспользоваться идиомой «виртуальных конструкторов» из главы 13. Не вдаваясь в

подробности, скажу, что это позволит вам объявить image чем-то приятным для глаза -

например, unsigned char image(sizeof Type) - нежели вызывать конструктор и деструктор Type вручную. Компиляторы С++ недолюбливают подобные фокусы, поэтому, прежде чем пускаться на авантюры, внимательно прочитайте главу 13.

Если AutoImage будет использоваться только для структур или классов, добавьте оператор ->:

Type* operator->() { return &current; } Обратите внимание: в отличие от предыдущих версий -> этот оператор не может быть константной функцией, поскольку current находится внутри *this и мы не можем гарантировать, что -> не будет использоваться для обращений к неконстантным функциям current.

Следующий класс демонстрирует возможное использование этого шаблона. Вмещающему объекту Foo незачем создавать свой образ, как в предыдущих указателях на объекты, поскольку все его переменные способны поддерживать свои образы по отдельности.

class Foo {

private:

AutoImage<int> some_integer;

AutoImage<Bar> bar;

public:

void Rollback()

{

some_integer.Rollback();

bar.Rollback();

}

void Commit()

{

some_integer.Commit();

bar.Commit();

}

void Snapshot()

{

some_integer.Snapshot();

bar.Snapshot();

}

int ProvideInt() const { return some_integer; }

void ChanheInt(int new_value)

{

if (!some_integer.HaveImage())

some_integer.Snapshot();

int&(some_integer) = new_value;

}

const Bar& ProvideBar() const { return bar; }

Bar& UpdateBar()

{

if (!bar.HaveImage())

bar.Shapshot();

return Bar&(bar);

}

};

Предполагается, что Bar соответствует необходимым условиям. Последние четыре функции перед тем, как обновлять переменную, создают «моментальный снимок» объекта. Для int получение копии по определению является константным по отношению к копируемой переменной. При вызове функции, изменяющей значение переменной, настает время делать снимок. Для работы с другой переменной, bar, предоставляется как константная, так и неконстантная функция. Конечно, хотелось бы просто перегрузить функцию ProvideBar(), чтобы одна перегруженная версия возвращала const Bar&, а другая - неконстантный Bar&, но тогда их сигнатуры будут совпадать. Помните: две функции не могут иметь одинаковые имена и аргументы и отличаться только типом возвращаемого значения. Я никогда не понимал этого ограничения С++, которое запрещает создавать константную и

неконстантнуюверсию оператора ->:

const Type* operator->() const; // Снимок не создается

Type* operator->() const; // Создает снимок

Конечно, это намного упростило бы жизнь, но назвать эти загадочные ограничения бесполезными нельзя - они дают знатокам С++ хорошую тему для разговоров на семинарах с коктейлями.

Раз уж речь зашла об ограничениях С++, упомяну еще об одном. Взгляните на приведенный выше код класса Foo. Работа некоторых его функций сводится к вызову одной и той же функции для всех переменных класса и в более общем случае - базовых классов. Скажем, Foo::Commit() просто вызывает Commit() для всех переменных. Весь повторяющийся код приходится писать вручную; в языке сильно не хватает макросредств, которые бы позволяли сказать: «Вызвать функцию Commit() для каждой переменной класса». Компилятор знает, как составить список такого рода (и использует его в конструкторах), но вам ни за что не скажет.