|
|
Бьерн Страуструп. Язык программирования С Второе дополненное издание
13.9 Управляющие классы
Концепция абстрактного класса дает эффективное средство для разделения интерфейса и его реализации. Мы применяли эту концепцию и получали постоянную связь между интерфейсом, заданным абстрактным типом, и реализацией, представленной конкретным типом. Так, невозможно переключить абстрактный итератор с одного класса-источника на другой, например, если исчерпано множество (класс set), невозможно перейти на потоки.
Далее, пока мы работаем с объектами абстрактного типа с помощью указателей или ссылок, теряются все преимущества виртуальных функций. Программа пользователя начинает зависеть от конкретных классов реализации. Действительно, не зная размера объекта, даже при абстрактном типе нельзя разместить объект в стеке, передать как параметр по значению или разместить как статический. Если работа с объектами организована через указатели или ссылки, то задача распределения памяти перекладывается на пользователя ($$13.10).
Существует и другое ограничение, связанное с использованием абстрактных типов. Объект такого класса всегда имеет определенный размер, но классы, отражающие реальное понятие, могут требовать память разных размеров.
Есть распространенный прием преодоления этих трудностей, а именно, разбить отдельный объект на две части: управляющую, которая определяет интерфейс объекта, и содержательную, в которой находятся все или большая часть атрибутов объекта. Связь между двумя частями реализуется с помощью указателя в управляющей части на содержательную часть. Обычно в управляющей части кроме указателя есть и другие данные, но их немного. Суть в том, что состав управляющей части не меняется при изменении содержательной части, и она настолько мала, что можно свободно работать с самими объектами, а не с указателями или ссылками на них. управляющая часть содержательная часть
Простым примером управляющего класса может служить класс string из $$7.6. В нем содержится интерфейс, контроль доступа и управление памятью для содержательной части. В этом примере управляющая и содержательная части представлены конкретными типами, но чаще содержательная часть представляется абстрактным классом.
Теперь вернемся к абстрактному типу set из $$13.3. Как можно определить управляющий класс для этого типа, и какие это даст плюсы и минусы? Для данного класса set можно определить управляющий класс просто перегрузкой операции ->: class set_handle { set* rep; public: set* operator->() { return rep; } set_handler(set* pp) : rep(pp) { }
};
Это не слишком влияет на работу с множествами, просто передаются объекты типа set_handle вместо объектов типа set& или set*, например: void my(set_handle s)
{ for (T* p = s->first(); p; p = s->next())
{
//
}
//
}
Бьерн Страуструп.
Язык программирования С++
359 void your(set_handle s)
{ for (T* p = s->first(); p; p = s->next())
{
//
}
//
} void user()
{ set_handle sl(new slist_set); set_handle v(new vector_set v(100)); my(sl); your(v); my(v); your(sl);
}
Если классы set и set_handle разрабатывались совместно,легко реализовать подсчет числа создаваемых множеств: class set { friend class set_handle; protected: int handle_count; public: virtual void insert(T*) = 0; virtual void remove(T*) = 0; virtual int is_member(T*) = 0; virtual T* first() = 0; virtual T* next() = 0; set() : handle_count(0) { }
};
Чтобы подсчитать число объектов данного типа set, в управляющем классе нужно увеличивать или уменьшать значение счетчика set_handle: class set_handle { set* rep; public: set* operator->() { return rep; } set_handle(set* pp)
: rep(pp) { pp->handle_count++; } set_handle(const set_handle& r)
: rep(r.rep) { rep->handle_count++; } set_handle& operator=(const set_handle& r)
{ rep->handle_count++; if (--rep->handle_count == 0) delete rep; rep
= r.rep; return
*this;
}
set_handle()
{ if (--rep->handle_count == 0) delete rep; }
};
Если все обращения к классу set обязательно идут через set_handle, пользователь может не беспокоиться о распределении памяти под объекты типа set.
На практике иногда приходится извлекать указатель на содержательную часть из управляющего класса и пользоваться непосредственно им. Можно, например, передать такой указатель функции, которая
Бьерн Страуструп.
Язык программирования С++
360 ничего не знает об управляющем классе. Если функция не уничтожает объект, на который она получила указатель, и если она не сохраняет указатель для дальнейшего использования после возврата, никаких ошибок быть не должно. Может оказаться полезным переключение управляющего класса на другую содержательную часть: class set_handle { set* rep; public:
// set* get_rep() { return rep; } void bind(set* pp)
{ pp->handle_count++; if (--rep->handle_count == 0) delete rep; rep
= pp;
}
};
Создание новых производных от set_handle классов обычно не имеет особого смысла, поскольку это - конкретный тип без виртуальных функций. Другое дело - построить управляющий класс для семейства классов, определяемых одним базовым. Полезным приемом будет создание производных от такого управляющего класса. Этот прием можно применять как для узловых классов, так и для абстрактных типов.
Естественно задавать управляющий класс как шаблон типа: template class handle {
T* rep; public:
T* operator->() { return rep; }
//
};
Но при таком подходе требуется взаимодействие между управляющим и "управляемым" классами.
Если управляющий и управляемые классы разрабатываются совместно, например, в процессе создания библиотеки, то это может быть допустимо. Однако, существуют и другие решения ($$13.10).
За счет перегрузки операции -> управляющий класс получает возможность контроля и выполнения каких-то операций при каждом обращении к объекту. Например, можно вести подсчет частоты использования объектов через управляющий класс: template class Xhandle {
T* rep; int count; public:
T* operator->() { count++; return rep; }
//
};
Нужна более сложная техника, если требуется выполнять операции как перед, так и после обращения к объекту. Например, может потребоваться множество с блокировкой при выполнении операций добавления к множеству и удаления из него. Здесь, по сути, в управляющем классе приходится дублировать интерфейс с объектами содержательной части: class set_controller { set* rep;
// public: lock(); unlock(); virtual void insert(T* p)
{ lock(); rep->insert(p); unlock(); }
Бьерн Страуструп. Язык программирования С++ 361 virtual void remove(T* p) { lock(); rep->remove(p); unlock(); } virtual int is_member(T* p) { return rep->is_member(p); } virtual T* first() { return rep->first(); } virtual T* next() { return rep->next(); } // }; Писать функции-переходники для всего интерфейса утомительно (а значит могут появляться ошибки), но не трудно и это не ухудшает характеристик программы. Заметим, что не все функции из set следует блокировать. Как показывает опыт автора, типичный случай, когда операции до и после обращения к объекту надо выполнять не для всех, а только для некоторых функций-членов. Блокировка всех операций, как это делается в мониторах некоторых операционных систем, является избыточной и может существенно ухудшить параллельный режим выполнения. Переопределив все функции интерфейса в управляющем классе, мы получили по сравнению с приемом перегрузки операции ->, то преимущество, что теперь можно строить производные от set_controller классы. К сожалению, мы можем потерять и некоторые достоинства управляющего класса, если к производным классам будут добавляться члены, представляющие данные. Можно сказать, что программный объем, который разделяется между управляемыми классами уменьшается по мере роста программного объема управляющего класса. 13.10 Управление памятью При проектировании библиотеки или просто программы с большим временем счета один из ключевых вопросов связан с управлением памятью. В общем случае создатель библиотеки не знает, в каком окружении она будет работать. Будет ли там ресурс памяти настолько критичен, что ее нехватка станет серьезной проблемой, или же серьезной помехой станут накладные расходы, связанные с управлением памятью? Один из основных вопросов управления памятью можно сформулировать так: если функция f() передает или возвращает указатель на объект, то кто должен уничтожать этот объект? Необходимо ответить и на связанный с ним вопрос: в какой момент объект может быть уничтожен? Ответы на эти вопросы особенно важны для создателей и пользователей таких контейнеров, как списки, массивы и ассоциативные массивы. С точки зрения создателя библиотеки идеальными будут ответы: "Система" и "В тот момент, когда объект больше никто не использует". Когда система уничтожает объект, обычно говорят, что она занимается сборкой мусора, а та часть системы, которая определяет, что объект больше никем не используется, и уничтожает его, называется сборщиком мусора. К сожалению, использование сборщика мусора может повлечь за собой накладные расходы на время счета и память, прерывания полезных функций, определенную аппаратную поддержку, трудности связывания частей программы на разных языках или просто усложнение системы. Многие пользователи не могут позволить себе этого. Говорят, что программисты на Лиспе знают, насколько важно управление памятью, и поэтому не могут отдать его пользователю. Программисты на С тоже знают, насколько важно управление памятью, и поэтому не могут оставить его системе. Поэтому в большинстве программ на С++ не приходится рассчитывать на сборщик мусора и нужно предложить свою стратегию размещения объектов в свободной памяти, не обращаясь к системе. Но реализации С++ со сборщиком мусора все-таки существуют. Рассмотрим самую простую схему управления памятью для программ на С++. Для этого заменим operator new() на тривиальную функцию размещения, а operator delete() - на пустую функцию: inline size_t align(size_t s) /* Даже в простой функции размещения нужно выравнивание памяти, чтобы на объект можно было настроить указатель произвольного типа */ { Бьерн Страуструп. Язык программирования С++ 362 union Word { void* p; long double d; long l; } int x = s + sizeof(Word) - 1; x -= x%sizeof(Word); return x; } st atic void* freep; // настроим start на свободную память void* operator new(size_t s) // простая линейная функция размещения { void* p = freep; s = align(s); freep += s; return p; } void operator delete(void*) { } // пусто Если память бесконечна, то наше решение дает сборщик мусора без всяких сложностей и накладных расходов. Такой подход не применим для библиотек, когда заранее неизвестно, каким образом будет использоваться память, и когда программа, пользующаяся библиотекой, будет иметь большое время счета. Такой способ выделения памяти идеально подходит для программ, которым требуется ограниченный объем памяти или объем, пропорциональный размеру входного потока данных. 13.10.1 Сборщик мусора Сборку мусора можно рассматривать как моделирование бесконечной памяти на памяти ограниченного размера. Помня об этом, можно ответить на типичный вопрос: должен ли сборщик мусора вызывать деструктор для тех объектов, память которых он использует? Правильный ответ - нет, поскольку, если размещенный в свободной памяти объект не был удален, то он не будет и уничтожен. Исходя из этого, операцию delete можно рассматривать как запрос на вызов деструктора (и еще это - сообщение системе, что память объекта можно использовать). Но как быть, если действительно требуется уничтожить размещенный в свободной памяти объект, который не был удален? Заметим, что для статических и автоматических объектов такой вопрос не встает, - деструкторы для них неявно вызываются всегда. Далее, уничтожение объекта "во время сборки мусора" по сути является операцией с непредсказуемым результатом. Она может совершиться в любое время между последним использованием объекта и "концом программы", а значит, в каком состоянии будет программа в этот момент неизвестно. Здесь использованы кавычки, потому что трудно точно определить, что такое конец программы. (прим. перев.) Трудно правильно запрограммировать такие операции и они не так полезны, как кажется. Задачу уничтожения объектов, если время этой операции точно не задано, можно решить с помощью программы обслуживания заявок на уничтожение. Назовем ее сервером заявок. Если объект необходимо уничтожить в конце программы, то надо записать в глобальный ассоциативный массив его адрес и указатель на функцию "очистки". Если объект удален явной операцией, заявка аннулируется. При уничтожении самого сервера (в конце программы) вызываются функции очистки для всех оставшихся заявок. Это решение подходит и для сборки мусора, поскольку мы рассматриваем ее как моделирование бесконечной памяти. Для сборщика мусора нужно выбрать одно из двух решений: либо удалять объект, когда единственной оставшейся ссылкой на него будет ссылка, находящаяся в массиве самого сервера, либо (стандартное решение) не удалять объект до конца программы, поскольку все- таки ссылка на него есть. Сервер заявок можно реализовать как ассоциативный массив ($$8.8): class Register { Map m; public: insert(void* po, void(*pf)()) { m[po]=pf; } remove(void* po) { m.remove(po); }
};
Register cleanup_register;
Бьерн Страуструп. Язык программирования С++ 363 Класс, постоянно обращающийся к серверу, может выглядеть так: class X { // static void cleanup(void*); public: X() { 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 Vector {
T* p; int sz; public:
Vector(int s) { p = new T[sz=s]; }
//
};
Если пользователь не будет заносить в контейнер вместо указателей на объекты сами объекты типа
Shape, то это решение подходит для обоих вариантов.
Vector vsp(200);
// нормально
Vector vs(200);
// ошибка при трансляции
К счастью, транслятор отслеживает попытку создать массив объектов абстрактного базового класса
Shape.
Однако, если используются указатели, создатель библиотеки и пользователь должны договориться, кто будет удалять хранимые в контейнере объекты. Рассмотрим пример: void f()
// противоречивое использование средств
// управления памятью
{
Vector v(10);
Circle* cp = new Circle; v[0] = cp; v[1] = new Triangle;
Square s;
Бьерн Страуструп.
Язык программирования С++
364 v[2] = &s; delete cp;
// не удаляет объекты, на которые настроены
// указатели, находящиеся в контейнере
}
Если использовать реализацию класса Vector из $$1.4.3, объект Triangle в этом примере навсегда останется в подвешенном состоянии (на него нет указателей), если только нет сборщика мусора.
Главное в управлении памятью это - это корректность. Рассмотрим такой пример: void g()
// корректное использование средств управления памятью
{
Vector v(10);
Circle* cp = new Circle; v[0] = cp; v[1] = new Triangle;
Square s; v[2] = &s; delete cp; delete v[1];
}
Рассмотрим теперь такой векторный класс, который следит за удалением занесенных в него указателей: template MVector {
T* p; int sz; public:
MVector(int s);
MVector();
//
}; template MVector::MVector(int s)
{
// проверка s p = new T[sz=s]; for (int i = 0; i} template MVector::MVector()
{ for (int i = 0; i}
Пользователь может рассчитывать, что содержащиеся в MVector указатели будут удалены. Отсюда следует, что после удаления MVector пользователь не должен обращаться с помощью указателей к объектам, заносившимся в этот контейнер. В момент уничтожения MVector в нем не должно быть указателей на статические или автоматические объекты, например: void h()
// корректное использование средств управления памятью
{
MVector v(10);
Circle* cp = new circle(); v[0] = cp; v[1] = new Triangle;
Square s; v[2] = &s; v[2] = 0;
// предотвращает удаление s
Бьерн Страуструп. Язык программирования С++ 365 // все оставшиеся указатели // автоматически удаляются при выходе } Естественно, такое решение годится только для контейнеров, в которых не содержатся копии объектов, а для класса Map ($$8.8), например, оно не годится. Здесь приведен простой вариант деструктора для MVector, но содержится ошибка, поскольку один и тот же указатель, дважды занесенный в контейнер, будет удаляться тоже два раза. Построение и уничтожение таких контейнеров, которые следят за удалением содержащихся в них объектах, довольно дорогостоящая операция. Копирование же этих контейнеров следует запретить или, по крайней мере, сильно ограничить (действительно, кто будет отвечать за удаление контейнер или его копия?): template MVector { private:
MVector(const
MVector&);
//предотвращает копирование
MVector& operator=(const MVector&); //то же самое
//
};
Отсюда следует, что такие контейнеры надо передавать по ссылке или указателю (если, вообще, это следует делать), но тогда в управлении памятью возникает трудность другого рода.
Часто бывает полезно уменьшить число указателей, за которыми должен следить пользователь.
Действительно, намного проще следить за 100 объектами первого уровня, которые, в свою очередь, управляют 1000 объектов нулевого уровня, чем непосредственно работать с 1100 объектами.
Собственно, приведенные в этом разделе приемы, как и другие приемы, используемые для управления памятью, сводятся к стандартизации и универсализации за счет применения конструкторов и деструкторов. Это позволяет свести задачу управления памятью для практически невообразимого числа объектов, скажем 100 000, до вполне управляемого числа, скажем 100.
Можно ли таким образом определить класс контейнера, чтобы программист, создающий объект типа контейнера, мог выбрать стратегию управления памятью из нескольких возможных, хотя определен контейнер только одного типа? Если это возможно, то будет ли оправдано? На второй вопрос ответ положительный, поскольку большинство функций в системе вообще не должны заботиться о распределении памяти. Существование же нескольких разных типов для каждого контейнерного класса является для пользователя ненужным усложнением. В библиотеке должен быть или один вид контейнеров (Vector или MVector), или же оба, но представленные как варианты одного типа, например: template PVector {
T** p; int sz; int managed; public:
PVector(int s, int managed = 0 );
PVector();
//
}; template PVector::PVector(int s, int m)
{
// проверка s p = new T*[sz=s]; if (managed = m) for (int i = 0; i} template PVector::PVector()
{ if (managed) { for (int i = 0; i Бьерн Страуструп. Язык программирования С++ 366 } delete p; } Примером класса, который может предложить библиотека для облегчения управления памятью, является управляющий класс из $$13.9. Раз в управляющем классе ведется подсчет ссылок на него, можно спокойно передавать объект этого класса, не думая о том, кто будет удалять доступные через него объекты. Это сделает сам объект управляющего класса. Но такой подход требует, чтобы в управляемых объектах было поле для подсчета числа использований. Введя дополнительный объект, можно просто снять это жесткое требование: template class Handle {
T* rep; int* pcount; public:
T* operator->() { return rep; }
Handle(const
T* pp)
: rep(pp), pcount(new int) { (*pcount) = 0; }
Handle(const
Handle& r)
: rep(r.rep), pcount(r.count) { (*pcount)++; } void bind(const Handle& r)
{ if (rep == r.rep) return; if (--(*pcount) == 0) { delete rep; delete pcount; } rep
= r.rep; pcount
= r.pcount;
(*pcount)++;
}
Handle& operator=(const Handle& r)
{ bind(r); return
*this;
}
Handle()
{ if (--(*pcount) == 0) { delete rep; delete pcount; }
}
};
|
|
|
Скачать 2.87 Mb.