C++: библиотека программиста

 
233 
{ 
if 
(!iterator->More()) 
Swap(); 
// 
Начать работу в другую сторону 
else 
{ 
VoidPtr* vp = iterator->Next(); 
if (vp->address >= inactive && 
vp->address < inactive + sizeof(*inactive)) 
{ 
void* 
new_space 
= 
active->Allocate(size); 
if (new_space == NULL) 
throw(OutOfMemory()); 
memcpy(new_space, 
vp->address, 
vp->size); 
vp->address 
= 
new_space; 
} 
} 
} 
Функцию 
Copy1()
необходимо вызывать как можно чаще, однако делать это можно в ходе 
нормальной работы программы. Новые объекты размещаются в активной половине, смешиваются со 
скопированными объектами, но это не приносит вреда. Поскольку перед копированием мы 
убеждаемся, что объект в данный момент находится в неактивном пространстве, созданные в активной 
половине объекты остаются без изменений. 
Внешние объекты 
Предположим, адрес объекта пришлось передать системной функции, которая ничего не знает ни о 
дескрипторах, ни о ведущих указателях. Такому объекту лучше оставаться на своем месте, пока 
системная функция не завершит свою работу! 
SystemCall(&aString); // 
aString 
не следует перемещать до тех пор, 
// пока его адрес остается в распоряжении системы 
Прежде всего, совершенно неочевидно, как получить адрес объекта, поскольку рассматривавшиеся до 
настоящего момента ведущие указатели и дескрипторы не предоставляли прямого доступа к адресам 
объектов. Но даже если предположить, что такая способность была добавлена, приходится действовать 
осторожно. Первое побуждение — включить в ведущий указатель флаг, показывающий, что объект не 
должен перемещаться. Но тем самым вы швырнете гнилой помидор в алгоритм уплотнения; вам 
придется тщательно обходить этот объект, чтобы не скопировать что-нибудь поверх него. Более 
удачный выход — убрать объект из сжимаемого пространства на все время, пока он должен оставаться 
на фиксированном месте. 
class Space { 
public: 
void 
Externalize(VoidPtr* 
vp) 
{ 
void* space = ::operator new(vp->size); 
memcpy(space, vp->address, vp->size); 
vp->address = space; 
} 
void 
Internalize(VoidPtr* 
vp) 
{ 
void* space = Allocate(vp->size); 
memcpy(space, vp->address, vp->size); 
::operator 
delete(vp->address); 
vp->address = space; 

---

 234 
} 
} 
Функция 
Externalize()
перемещает объект за пределы сжимаемого пространства; 
Internalize()
возвращает его обратно. Алгоритм 
Copy1()
будет нормально работать, поскольку не пытается 
перемещать объекты вне неактивной половины. 
Этот способ также может применяться для передачи адреса переменной класса или 
this
(см. ниже) 
некоторой функции класса или глобальной функции. Допустим, вам потребовалось организовать 
взаимодействие своих классов с коммерческой библиотекой, которая понятия не имеет о ваших 
хитроумных правилах уплотнения. 
Помимо необходимости узнавать, когда внешний код перестал пользоваться вашим объектом, этот 
вариант может вызвать проблемы и при частой передаче адресов внешним функциям, поскольку 
копирование целого объекта из пространства памяти и обратно может обходиться довольно дорого. 
Алгоритм Бейкера: уход и кормление в C++ 
Практическое использование описанных выше алгоритмов требует нескольких жестких ограничений. 
Алгоритм Бейкера для объектов С++ напоминает котенка, которого ваш ребенок приносит в дом и 
клянется «всегда-всегда» кормить и заботиться. Другими словами, все совершенно искренне клянутся 
соблюдать правила, а вам лучше надевать передник и идти за тряпкой. 
Очереди операций и указатель this 
Если на момент вызова 
Copy1()
существует указатель 
this
, то объект, на который он ссылается, 
может переместиться из одной половины в другую. При этом 
this
будет радостно ссылаться на 
старую копию. Мы позаботились обо всех остальных стековых переменных и превратили их в 
дескрипторы. Теперь, чтобы получить доступ к объекту, им приходится разворачиваться на 180º и 
действовать через ведущий указатель. Возможно, силовое решение, которое работает, хотя и 
ненамного лучше — потребовать, чтобы функция 
Copy1()
всегда вызывалась в самом конце функций 
класса: 
class Foo { 
public: 
void 
Fn() 
{ 
// 
Код, который делает нечто осмысленное 
VoidPtr::pool->Copy1(); 
} 
}; 
Разумеется, все будет нормально лишь в том случае, если объект вызывавший 
Fn()
, ну будет 
использовать свой указатель 
this
после возвращения из 
Fn()
. Не знаю, как вы, а лично я предпочитаю 
спать спокойно и не думать о том, как один из 2435 программистов, работающих с моей библиотекой 
классов, придумает способ все испортить. 
Более достойное решение — сделать так, чтобы функция 
Copy1()
вызывалась из некоторого цикла 
событий верхнего уровня. На самом деле нежелательно, чтобы в момент вызова 
Copy1()
функции 
исчезающих объектов находились в стеке. В результате получается архитектура, которую я называю 
опосредованной (inside-out), — функция класса не выполняет работу сама, а создает объект-операцию 
(operational object) и направляет его в некоторую главную очередь. Это распространенное решение 
встречается во многих библиотеках классов. 
class Operation { 
friend void MainLoop(); 
private: 
static Queue OperationQ; 
public: 
virtual void DoSomething() = 0; 
void Post() { OperationQ.Push(this); } 

---