Функция Externa1ize() перемещает объект за пределы сжимаемого пространства; Interna1ize() возвращает его обратно. Алгоритм Copy1() будет нормально работать, поскольку не пытается перемещать объекты вне неактивной половины.

Этот способ также может применяться для передачи адреса переменной класса или this (см. ниже) некоторой функции класса или глобальной функции. Допустим, вам потребовалось организовать взаимодействие своих классов с коммерческой библиотекой, которая понятия не имеет о ваших хитроумных правилах уплотнения.

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

Алгоритм Бейкера: уход и кормление в C++

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

Очереди операций и указатель this

Если на момент вызова Copy1() существует указатель this, то объект, на который он ссылается, может переместиться из одной половины в другую. При этом this будет радостно ссылаться на старую копию. Мы позаботились обо всех остальных стековых переменных и превратили их в дескрипторы. Теперь, чтобы получить доступ к объекту, им приходится разворачиваться на 180° и действовать через ведущий указатель. Возможно, силовое решение, которое работает, хотя и ненамного лучше - потребовать, чтобы функция Copy1() всегда вызывалась в самом конце функций класса:

class Foo { public:

void Fn()

Код, который делает нечто осмысленное VoidPtr::poo1->Copy1();

Разумеется, все будет нормально лишь в том случае, если объект вызывавший Fn() , ну будет использовать свой указатель this после возвращения из Fn(). Не знаю, как вы, а лично я предпочитаю спать спокойно и не думать о том, как один из 2435 программистов, работающих с моей библиотекой классов, придумает способ все испортить.

Более достойное решение - сделать так, чтобы функция Copy1() вызывалась из некоторого цикла событий верхнего уровня. На самом деле нежелательно, чтобы в момент вызова Copy1() функции исчезающих объектов находились в стеке. В результате получается архитектура, которую я называю опосредованной (inside-out), - функция класса не выполняет работу сама, а создает объект-операцию (operational object) и направляет его в некоторую главную очередь. Это распространенное решение встречается во многих библиотеках классов.

class Operation { friend void MainLoop(); private:

static Queue<Operation> OperationQ; public:

virtual void DoSomethingO = 0;

void Post() { OperationQ.Push(this); }

void MainLoop()

Operation* op;

while ((op = Operation::OperationQ.Pop()) != NULL)

op->DoSomething(); object space->Copy1();

Если теперь объект захочет выполнить какое-нибудь действие, он не выполняет его сам, а создает класс, производный от Operation, и заносит его в очередь. Если обработка связана с итерациями, объект Operation продолжает направлять себя в очередь в конце каждого вызова DoSomething() до завершения итераций. Приведу краткий набросок традиционного подхода и опосредованной архитектуры:

Традиционный способ сделать что-то

void Foo::SomeOperation()

for (...)

OnePass();

Если операция занимает много времени, перед вами возникают два неудобных варианта: не выполнять сборку мусора и уплотнение до завершения Foo::SomeOperation(), а следовательно, утратить многие преимущества от управления памятью; или косвенно вызвать Copy1() во время вызова Foo::SomeOperation() , а это небезопасно. Очередь операций предоставляет другое решение проблемы:

Опосредованная архитектура с очередями операций class FooSomeOperation : public Operation } public:

virtual void DoSomething();

Выполнить один проход if ( еще не готово)

this->Post(); Послать заново для следующего захода delete this;

void Foo::SomeOperation()

Operation* op = new FooSomeOperation(args); op->Post();

op->DoSomething выполняет работу

Теперь функция Copy1() заведомо не будет вызвана в момент нахождения в стеке FooSomeOperation::DoSomething(). Подобные очереди операций так часто приносят пользу, что являются едва ли не стандартной возможностью объектно-ориентированных библиотек классов. Сколько библиотек - столько и вариаций (скажем, назначение приоритетов операций или возможность блокирования одних операций до завершения других), но во всех разновидностях встречается одна общая черта - максимальное освобождение стека на время периодического выполнения вспомогательных операций.

Адреса переменных класса

Аналогичная проблема возникает и при получении адреса переменной класса, даже если это происходит в функциях класса, которым мы управляем. Именно по этой причине мы и потребовали, чтобы везде применялись дескрипторы. Благодаря опосредованной методике проблем не возникает - при условии, что вы получаете адрес переменной класса, используете и забываете про него в течение одного цикла. Впрочем, от хлопот, связанных с опосредованной архитектурой, можно и отказаться. Если вы абсолютно уверены, что адрес не сохранится до следующего вызова функции Copy1() , то можете избирательно снимать требование обязательного применения дескрипторов.

Множественное наследование

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

Неустойчивые объекты

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

Уплотнение на месте

Очевидный недостаток алгоритма Бейкера заключается в напрасной потере половины памяти. Существует и другой, мене очевидный недостаток - при каждом проходе все объекты копируются из одного места памяти в другое. Такое копирование может отрицательно повлиять на быстродействие программы. Обе проблемы решаются в другом алгоритме, который называется уплотнением на месте (compaction in place). Вместо двух половин существует единое пространство, а в процессе уплотнения все объекты смещаются вниз. На следующей диаграмме показано состояние памяти до и после уплотнения.

После

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

Базовый класс VoidPtr

Память под объекты всегда выделяется снизу вверх. Если новые объекты VoidPtr всегда будут добавляться в конец связанного списка, то список всегда будет отсортирован по возрастанию адресов