public:

P(); Занести this в список

P(const P<Type>& p); Занести this в список

~P(); Удалить this из списка

P<Type>& operator=(const P<Type>& p); Не изменяя список,

скопировать p.pointee

Все для умных указателей

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

class Foo { private:

P<Bar> bar; Указатель автоматически заносится в скрытую коллекцию

При конструировании Foo вызывается соответствующий конструктор P, который автоматически заносит bar в скрытую коллекцию. При уничтожении Foo вызывает деструктор P, который удаляет bar из коллекции. Разумеется, вместо двусвязного списка можно воспользоваться другими структурами данных. Кроме того, как вы вскоре убедитесь, для всех этих специализированных указателей стоит создать общий базовый класс и сохранить их все в одной коллекции. В приведенном выше фрагменте для каждого типа указателя создается отдельная коллекция.

Анализ экземпляров

Более радикальный подход - использовать самые обычные указатели и предусмотреть средства для перебора всех указателей, внедренных в экземпляр.

class Foo { private:

Bar* bar;

В данной схеме это разрешается, при условии, что какая-то очень сложная архитектура сможет определить Bar* по имеющемуся Foo. Чтобы реализовать ее, нам понадобится код, который знает структуру каждого экземпляра (а точнее, умеет находить переменные класса, которые являются адресами или могут содержать адреса посредством рекурсии), и возможность точно определить тип указываемого объекта. Например, успешно найденный bar не поможет, если вы не знаете, с чем имеете дело - с настоящим Bar или каким-то классом, производным от Bar. В производном классе могут появиться дополнительные указатели, отсутствующие в Bar .

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

Стековые переменные

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

Дескрипторы, повсюду дескрипторы

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

class Foo { private:

H<Bar> bar; Дескриптор Bar public:

H<Bar> GetBar() { return bar; }

Здесь H - шаблон дескриптора (вроде тех, которые мы рассматривали в предыдущих главах). Каждый H<Bar> представляет собой умный указатель на ведущий указатель на Bar. Функции, косвенно открывающие переменные класса (такие как GetBar()), возвращают копию дескриптора. Все ведущие указатели (по крайней мере, в этой версии) живут в специальном пространстве памяти, поэтому найти их несложно.

Ниже описывается одна из несложных реализаций уплотнения с применением дескрипторов. Конечно, возможны и другие варианты.

Общее описание архитектуры

В общих чертах наша архитектура строится на следующих принципах:

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

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

Каждый ведущий указатель обеспечивает подсчет ссылок и удаляет себя, когда счетчик переходит от 1 к 0. В свою очередь, его деструктор вызывает деструктор указываемого объекта и, в зависимости от используемых алгоритмов, пытается (или не пытается) вернуть занимаемую объектом память.

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

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

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

Ведущие указатели

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

1 . Ведение счетчика ссылок.

2. Хранение их в специальном пространстве памяти с поддержкой перебора.

3. Вызов деструктора указываемого объекта в деструкторе указателя. В зависимости от используемого алгоритма сборки мусора мы одновременно пытаемся (или не пытаемся) вернуть занимаемую объектом память. В нашем примере не стоит беспокоиться о возврате памяти объекта.

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

Ниже показан абстрактный базовый класс, удовлетворяющий этим требованиям.

class VoidPtrPool; Используется для создания, уничтожения

и перебора VoidPtr

class VoidPtr {

friend class VoidPtrPool;

private:

unsigned long refcount; Счетчик ссылок protected:

void* address; Адрес указываемого объекта

size t size; Размер указываемого объекта в байтах

VoidPtr() : address(NULL), size(0), refcount(0) {}

VoidPtr(void* adr, size t s) : address(adr), size(s), refcount(0) {} public:

static VoidPtrPool* pool;

virtual ~VoidPtr() { size = 0; address = NULL; } void* operator new(size t)

if (pool == NULL)

pool = new VoidPtrPool; return poo1->Al1ocate();

void operator de1ete(void* space)

{ poo1->Dea11ocate((VoidPtr*)space); } void Grab() { refcount++; } void Re1ease()

if (refcount > 0) refcount-- ; if (refcount <= 0) delete this;

Шаблон ведущего указателя

Наш ведущий указатель представляет собой шаблон, производный от VoidPtr . Он существует в основном для того, чтобы реализовать оператор -> и виртуальный деструктор, который знает, какой деструктор должен вызываться для указываемого объекта. Я решил запретить копирование и присваивание. При копировании дескриптора должен копироваться адрес ведущего указателя, а не сам ведущий указатель или указываемый объект. Следовательно, нет особой необходимости поддерживать копирование и присваивание для ведущих указателей. Как обычно, существует множество вариаций на тему конструкторов. В данном случае я выбрал ту, в которой конструктор ведущего указателя создает указываемый объект.

template <c1ass Type> class MP : public VoidPtr {

private: Чтобы запретить копирование и присваивание

MP(const MP<Type>&) {}

MP<Type>& operator=(const MP<Type>&) { return this; } public:

MP() : VoidPtr(new Type, sizeof(Type)) {}

virtual ~MP() { ((Type*)address)->Type::~TypeOf(); }