236
Адреса переменных класса
Аналогичная проблема возникает и при получении адреса переменной класса, даже если это происходит в функциях класса, которым мы управляем. Именно по этой причине мы и потребовали, чтобы везде применялись дескрипторы. Благодаря опосредованной методике проблем не возникает — при условии, что вы получаете адрес переменной класса, используете и забываете про него в течение одного цикла. Впрочем, от хлопот, связанных с опосредованной архитектурой, можно и отказаться. Если вы абсолютно уверены, что адрес не сохранится до следующего вызова функции Copy1(), то можете избирательно снимать требование обязательного применения дескрипторов.
Множественное наследование
Множественное наследование безопасно при условии соблюдения всех приведенных выше рекомендаций по уходу и кормлению указателя this. То обстоятельство, что this пляшет в памяти при вызове функций второго и третьего базового класса, не вызовет новых проблем — это все та же проблема с this, только замаскированная. Конечно, вы никогда не должны возвращать адрес объекта, преобразованного к базовому классу, но передача this тоже небезопасна.
Неустойчивые объекты
Объекты, адреса которых (в отличие от адресов их ведущих указателей) передаются за пределы вашей зоны контроля — скажем, при вызове системной функции — необходимо сначала вывести из очищаемого пространства. Самое простое решение — создать объект-операцию, которая перемещает свой объект и вызывает системную функцию, когда оказывается в новом безопасном месте.
Уплотнение на месте
Очевидный недостаток алгоритма Бейкера заключается в напрасной потере половины памяти. Существует и другой, мене очевидный недостаток — при каждом проходе все объекты копируются из одного места памяти в другое. Такое копирование может отрицательно повлиять на быстродействие программы. Обе проблемы решаются в другом алгоритме, который называется уплотнением на месте (compaction in place). Вместо двух половин существует единое пространство, а в процессе уплотнения все объекты смещаются вниз. На следующей диаграмме показано состояние памяти до и после уплотнения.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
До |
|
После |
Копирование объектов должно происходить в правильном порядке, снизу вверх, в противном случае объекты будут накладываться друг на друга. Этого можно добиться двумя способами: отсортировать ведущие указатели перед началом перебора или изначально хранить их в отсортированном порядке. Хранить ведущие указатели в двусвязном списке, отсортированном по адресу указываемого объекта, довольно просто — при условии, что вы готовы потратить лишнюю пару слов для указателей на следующий и предыдущий элемент. Шаблон ведущего указателя и дескрипторы аналогичны тем, которыми мы пользовались до настоящего момента. Базовый класс VoidPtr был усовершенствован для хранения экземпляров в связанном списке.
Базовый класс VoidPtr
Память под объекты всегда выделяется снизу вверх. Если новые объекты VoidPtr всегда будут добавляться в конец связанного списка, то список всегда будет отсортирован по возрастанию адресов
237
указываемых объектов. Конструкторы (см. далее) напрямую работают с переменной VoidPtrPool::tail. Деструктор исключает экземпляр из списка. Во всем остальном класс VoidPtr остался прежним. Ниже показаны изменения в VoidPtr.
class VoidPtr { private:
// Новые переменные для ведения списка
VoidPtr* next; |
// Следующий элемент списка |
VoidPtr* previous; |
// Предыдущий элемент списка |
protected: |
|
// Изменившиеся конструкторы
VoidPtr() : address(NULL), size(0), refcount(0), next(NULL), previous(NULL) {}
VoidPtr(void* addr, size_t s) : address(addr), size(s), refcount(0), next(NULL), previous(pool->tail->previous)
{
pool->tail->next = this; pool->tail = this;
}
public:
// Измененный деструктор virtual ~VoidPtr()
{
if (size != 0)// Активный указатель – исключить из списка
{
if (previous != NULL) previous->next = next;
if (next != NULL) next->previous = previous;
if (pool->tail == this) pool->tail = previous;
}
size = 0; address = NULL;
}
};
Пул ведущих указателей
Изменения в пуле ведущих указателей VoidPtrPool также весьма тривиальны.
class VoidPtrPool { |
// Как и прежде, плюс следующее |
friend class VoidPtr; |
// Обеспечивает доступ к tail |
private: |
|
// Новые переменные для ведения списка
VoidPtr head; |
// Фиктивный VoidPtr, который ссылается |
|
// на список активных указателей |
VoidPtr* tail; |
// Конец списка |
public:
// Новая версия конструктора
VoidPtrPool() : block_list(NULL), free_list(NULL), tail(&head) {}
};
238
Класс VoidPtrPool идентичен тому, который использовался в алгоритме Бейкера, с добавлением связанного списка активных VoidPtr.
Итератор ведущих указателей
Итератор ведущих указателей устроен элементарно. Он просто перебирает элементы списка от начала к концу — иначе говоря, от нижних адресов памяти к верхним.
class VoidPtrPoolIterator : public VoidPtrIterator { private:
VoidPtr* next; public:
VoidPtrIterator(VoidPtr* first) : next(first) {} virtual bool More() { return next != NULL; } virtual VoidPtr* Next()
{
VoidPtr* vp = next; next = next->next; return vp;
}
};
VoidPtrIterator* VoidPtrPool::iterator()
{
return new VoidPtrPoolIterator(&head.next);
}
Алгоритм уплотнения
Алгоритм уплотнения выглядит так просто, что его можно было бы и не приводить.
class Space { private:
unsigned long next_byte; unsigned char bytes[SPACESIZE];
public:
Space() : next_byte(0) {} void* Allocate(size_t size); void Compact();
};
void* Space::Allocate(size_t size)
{
// Выровнять на границу слова size = ROUNDUP(size);
if (next_byte + size > SPACESIZE)
{
Compact();
if (next_byte + size > SPACESIZE) // Исключение – нехватка памяти
}
void* space = &bytes[next_byte]; next_byte += size;
return space;
}