процессе сохранения коллекции на носителе информации или в любой момент при отсутствии активных итераторов и курсоров.

Иногда объект может находиться сразу как во вставленном, так и в удаленном состоянии; вставка произошла после того, как итератор был сконструирован, а удаление - до уничтожения итератора. В сущности, для каждого объекта можно вести целый журнал вставок и удалений, если для этих событий хватит жизненного срока вашего итератора. Для ведения такого журнала подходят многие различные структуры данных. Эта побочная тема достаточно интересна, хотя она и не имеет особого отношения к рассматриваемым идиомам С++. Чтобы обеспечить необходимый уровень инкапсуляции, мы внесем некоторые изменения в концепцию внутреннего итератора из предыдущего раздела.

Класс временных меток

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

class Timestamp { private:

static int 1ast time; Используется для присваивания числа int stamp; public:

Timestamp() : stamp(++1ast time) {}

bool operator>(Timestamp ts) { return stamp > ts.stamp; } bool operator>=(Timestamp ts) { return stamp >= ts.stamp; } bool operator<(Timestamp ts) { return stamp < ts.stamp; } bool operator<=(Timestamp ts) { return stamp <= ts.stamp; } bool operator==(Timestamp ts) { return stamp == ts.stamp; } bool operator!=(Timestamp ts) { return stamp != ts.stamp; }

Внутренний итератор с временной пометкой

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

class InternalIterator { public:

bool More(Timestamp as of); Foo* Next(Timestamp as of); bool Peek(Timestamp as of);

Внутренний итератор будет пропускать объекты, отсутствовавшие в коллекции в указанное время. Способы внутренней реализации

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

вставки. Существуют и другие возможности реализации (например, через списки исключений), однако методика журналов удалений по крайней мере демонстрирует концепцию.

Внешний итератор с временной пометкой

Внешний итератор представляет собой тривиальную оболочку для только что описанного внутреннего итератора:

class RealExternalIterator : public ExternalIterator { private:

InternalIterator* iter;

Timestamp my time; Время конструирования this

bool Accept(Foo*); Фильтрующая функция

public:

RealExternalIterator(Co11ection* c) : iter(c->Iterator()) {} virtual bool More() {

while (iter.More(my time)) {

if (Accept(iter->Peek(my time)))

return true; (void)iter->Next(my time);

return false;

virtual Foo* Next() { return iter->Next(my time); }

Безаргументный конструктор Timestamp использует для пометки текущее время. Во многих ситуациях функция Accept() всегда возвращает true, и ее можно убрать.

Пример

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

Ненадежный коммерческий класс словаря

В реальном мире редко приходится начинать с пустого места. Обычно в вашем распоряжении уже имеются готовые классы коллекций. Даже если они работают не совсем так, как хочется, по крайней мере они избавят вас от нудного переписывания любимых глав из книг Кнута при реализации базовых структур данных. В том же реальном мире эти классы обычно не обращают особого внимания на проблему надежности итераторов, так что наш пример никак не назовешь абстрактным. Для пущего реализма мы будем считать, что коллекция представляет собой словарь, который индексирует значение типа void* и возвращает void* в качестве ключа. Имеется пассивный итератор Slot, реальная структура которого спрятана глубоко внутри класса словаря. Открытый интерфейс выглядит так:

class Dictionary { public:

Dictionary(); Создает пустой словарь

Dictionary(const Dictionary&); Конструктор копий ~Dictionary();

Dictionary& operator=(const Dictionary&); void AddEntry(void* key, void* value);

bool At(void* key, void*& value); void RemoveEntry(void* key);

typedef void* Slot; Настоящее объявление надежно спрятано Slot First(); Возвращает Slot для перебора

Эквивалент нашей функции "Peek"

bool GetCurrent(Slot slot, void*& key, void*& value);

Эквивалент нашей функции "Next"

bool GetNext(Slot& slot, void*& key, void*& value);

Функция AddEntry() заносит в словарь новое значение с заданным ключом. Если ключ уже существует для другого значения, значение заменяется новым. Функция At() возвращает логический код, который показывает, присутствует ли ключ в словаре; если присутствует, функция возвращает true и value (значение, соответствующее данному ключу). Функция RemoveEntry() удаляет ключ и связанное с ним значение. Функция First() возвращает пассивный итератор, направленный таким образом, чтобы первый вызов GetNext() возвратил первый элемент словаря. Функция GetCurrent() возвращает пару ключ/значение, находящуюся в текущей позиции Slot. Функция GetNext() возвращает пару ключ/значение и перемещает итератор к следующему элементу. Единственное отличие между этими функциями заключается в перемещении логической позиции после получения объекта.

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

Класс журнала

Ниже приведен открытый интерфейс класса, в котором хранится история вставок/удалений для объекта. Этот класс использует рассмотренный выше класс Timestamp - он образует вторую составляющую пар ключ/значение, хранящихся в словаре. В реализации нет ничего интересного, поэтому я ее пропускаю.

class History { public:

History(); Пустой журнал

void Insert(Timestamp); Вставка в заданное время void Remove(Timestamp); Удаление в заданное время bool Exists(Timestamp); В заданное время bool Exists(); В настоящий момент

Функция Exists(Timestamp) возвращает true, если в заданное время последней операцией была вставка, и false - если последней операцией было удаление или до этого времени вообще не было операций. Безаргументная функция Exists() является синонимом для Exists(Timestamp) с очень большим значением времени - то есть до настоящего момента.

Абстрактный базовый класс

Класс набора делится на две части: абстрактный базовый класс, работающий с void*, и производный параметризованный класс, в который добавлена безопасность типов. Абстрактный базовый класс выглядит так:

В файле Set.h

class SetBase : private Dictionary { friend class InternalIterator; protected:

SetBase(); Чтобы класс был абстрактным