Vector<Shape*> v(10);

Circle* cp = new Circle; v[0] = cp;

v[1] = new Triangle; Square s;

Класс, постоянно обращающийся к серверу, может выглядеть так:

class X { ...

static void cleanup(void*); public:

cleanup register.insert(this,&cleanup); ...

~X() { cleanup(this); }

void X::cleanup(void* pv)

X* px = (X*)pv;

cleanup register.remove(pv); очистка

Чтобы в классе Register не иметь дела с типами, мы использовали статическую функцию-член с указателем типа void*.

13.10.2 Контейнеры и удаление

Допустим, что у нас нет бесконечной памяти и сборщика мусора. На какие средства управления памятью может рассчитывать создатель контейнера, например, класса Vector? Для случая таких простых элементов, как int, очевидно, надо просто копировать их в контейнер. Столь же очевидно, что для других типов, таких, как абстрактный класс Shape, в контейнере следует хранить указатель. Создатель библиотеки должен предусмотреть оба варианта. Приведем набросок очевидного решения:

template<class T> Vector {

T* p; int sz; public:

Vector(int s) { p = new T[sz=s]; } ...

Если пользователь не будет заносить в контейнер вместо указателей на объекты сами объекты типа Shape, то это решение подходит для обоих вариантов.

Vector<Shape*> vsp(200); нормально

Vector<Shape> vs(200); ошибка при трансляции

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

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

void f()

противоречивое использование средств управления памятью

v[2] = &s;

delete cp; не удаляет объекты, на которые настроены

указатели, находящиеся в контейнере

Если использовать реализацию класса Vector из $$1.4.3, объект Triangle в этом примере навсегда останется в подвешенном состоянии (на него нет указателей), если только нет сборщика мусора. Главное в управлении памятью это - это корректность. Рассмотрим такой пример:

void g()

корректное использование средств управления памятью

Vector<Shape*> v(10); Circle* cp = new Circle; v[0] = cp;

v[1] = new Triangle; Square s; v[2] = &s; delete cp; delete v[1];

Рассмотрим теперь такой векторный класс, который следит за удалением занесенных в него указателей:

template<class T> MVector {

T* p;

int sz; public:

MVector(int s);

~MVector();

...

template<class T> MVector<T>::MVector(int s)

проверка s p = new T[sz=s];

for (int i = 0; i<s; p[i] = 0;

template<class T> MVector<T>::~MVector()

for (int i = 0; i<s; delete p[i];

delete p;

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

void h()

корректное использование средств управления памятью

MVector<Shape*> v(10); Circle* cp = new circle(); v[0] = cp;

v[1] = new Triangle; Square s; v[2] = &s;

v[2] = 0; предотвращает удаление s

MVector& operator=(const MVector&); то же самое

Отсюда следует, что такие контейнеры надо передавать по ссылке или указателю (если, вообще, это следует делать), но тогда в управлении памятью возникает трудность другого рода.

Часто бывает полезно уменьшить число указателей, за которыми должен следить пользователь. Действительно, намного проще следить за 1 00 объектами первого уровня, которые, в свою очередь, управляют 1 000 объектов нулевого уровня, чем непосредственно работать с 11 00 объектами. Собственно, приведенные в этом разделе приемы, как и другие приемы, используемые для управления памятью, сводятся к стандартизации и универсализации за счет применения конструкторов и деструкторов. Это позволяет свести задачу управления памятью для практически невообразимого числа объектов, скажем 1 00 000, до вполне управляемого числа, скажем 1 00.

Можно ли таким образом определить класс контейнера, чтобы программист, создающий объект типа контейнера, мог выбрать стратегию управления памятью из нескольких возможных, хотя определен контейнер только одного типа? Если это возможно, то будет ли оправдано? На второй вопрос ответ положительный, поскольку большинство функций в системе вообще не должны заботиться о распределении памяти. Существование же нескольких разных типов для каждого контейнерного класса является для пользователя ненужным усложнением. В библиотеке должен быть или один вид контейнеров (Vector или MVector), или же оба, но представленные как варианты одного типа, например:

template<class T> PVector {

T** p;

int sz;

int managed;

public:

PVector(int s, int managed = 0 );

~PVector();

...

template<class T> PVector<T>::PVector(int s, int m)

проверка s

p = new T*[sz=s];

if (managed = m)

for (int i = 0; i<s; p[i] = 0;

template<class T> PVector<T>::~PVector()

все оставшиеся указатели автоматически удаляются при выходе

Естественно, такое решение годится только для контейнеров, в которых не содержатся копии объектов, а для класса Map ($$8.8), например, оно не годится. Здесь приведен простой вариант деструктора для MVector, но содержится ошибка, поскольку один и тот же указатель, дважды занесенный в контейнер, будет удаляться тоже два раза.

Построение и уничтожение таких контейнеров, которые следят за удалением содержащихся в них объектах, довольно дорогостоящая операция. Копирование же этих контейнеров следует запретить или, по крайней мере, сильно ограничить (действительно, кто будет отвечать за удаление контейнер или его копия?):

template<class T> MVector { private:

MVector(const MVector&); предотвращает копирование

if (managed) {

for (int i = 0; i<s; delete p[i];