delete p;

Примером класса, который может предложить библиотека для облегчения управления памятью, является управляющий класс из $$1 3.9. Раз в управляющем классе ведется подсчет ссылок на него, можно спокойно передавать объект этого класса, не думая о том, кто будет удалять доступные через него объекты. Это сделает сам объект управляющего класса. Но такой подход требует, чтобы в управляемых объектах было поле для подсчета числа использований. Введя дополнительный объект, можно просто снять это жесткое требование:

template<class T> 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; }

13.10.3 Функции размещения и освобождения

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

В разделах $$5.5.6 и $$6.7 было показано как с помощью определения функций X::operator new() и X::operator delete() можно использовать функцию размещения для объектов класса X. Здесь есть определенная трудность. Для двух классов X и Y функции размещения могут быть настолько сходными, что желательно иметь одну такую функцию. Иными словами, желательно иметь в библиотеке такой класс, который предоставляет функции размещения и освобождения, пригодные для размещения объектов данного класса. Если такой класс есть, то функции размещения и освобождения для данного класса получаются за счет привязки к нему общих функций размещения и освобождения:

class X {

public:

void* operator new(size t) { return my pool.alloc(); } void operator delete(void* p) { my pool.free(p); }

В приведенном примере

Pool X::my pool(sizeof(X));

С помощью класса Pool память распределяется блоками одного размера. объект my pool отводит память блоками размером sizeof(X).

Составляется описание класса X и используется Pool с учетом оптимизации скорости программы и компактности представления. Обратите внимание, что размер выделяемых блоков памяти является для класса встроенным , поэтому задающий размер параметр функции X::operator new() не используется. Используется вариант функции X::operator delete() без параметра. Если класс Y является производным класса X, и sizeof(Y)>sizeof(X), то для класса Y должны быть свои функции размещения и освобождения. Наследование функций класса X приведет к катастрофе. К счастью, задать такие функции для Y очень просто.

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

Приведем описание класса Pool:

class Pool {

struct Link { Link* next; } const unsigned esize; Link* head; Pool(Pool&); void operator= (Pools); void grow(); public:

Pool(unsigned n); ~Pool(); void* alloc(); void free(void* b);

защита от копирования защита от копирования

inline void* Pool::alloc()

if (head==0) grow(); Link* p = head; head = p->next; return p;

inline void Pool::free(void* b)

Link* p = p->next = head = p;

(Link*) b;

head;

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

static Pool my pool;

Pool::Pool(unsigned sz) : esize(sz)

head = 0;

Функция Pool::grow() будет связывать все элементы в список квантов свободной памяти head, образуя из них новый блок. Определения остальных функций-членов оставлены в качестве упражнений 5 и 6 в $$13.11.

void Pool::grow()

const int overhead = 12; const int chunk size = 8*1024-overhead; const int nelem = (chunk size-esize)/esize; char* start = new char[chunk size]; char* last = &start[(nelem-1)*esize]; for (char* p = start; p<last; p+=esize)

((Link*)p)->next = ((Link*)p)+1; ((Link*)last)->next = 0; head = (Link*)start;

1 3.11 Упражнения

1. (*3) Завершите определения функций-членов класса Type info.

2. (*3) Предложите такую структуру объекта Type info, чтобы функция Type info::get info() стала лишней, и перепишите с учетом этого функции-члены Type info.

3. (*2.5) Насколько наглядно вы сможете записать примеры с Dialog box, не используя макроопределения (а также расширения языка)? Насколько наглядно вам удастся записать их, используя расширения языка?

4. (*4) Исследуйте две широко распространенные библиотеки. Классифицируйте все библиотечные классы, разбив их на: конкретные типы, абстрактные типы, узловые классы, управляющие классы и интерфейсные классы. Используются ли абстрактные узловые классы и конкретные узловые классы? Можно ли предложить более подходящее разбиение классов этих библиотек? Используется ли обширный интерфейс? Какие имеются средства динамической информации о типе (если они есть)? Какова стратегия управления памятью?

5. (*3) Определите шаблонный вариант класса Pool из $$13.10.3. Пусть размер выделяемого элемента памяти будет параметром шаблона типа, а не конструктора.

6. (*2.5) Усовершенствуйте шаблон типа Pool из предыдущего упражнения так, чтобы некоторые элементы размещались во время работы конструктора. Сформулируйте в чем будет проблема переносимости, если использовать Pool с типом элементов char, покажите как ее устранить.

7. (*3) Если ваша версия С++ прямо не поддерживает динамические запросы о типе, обратитесь к своей основной библиотеке. Реализован ли там механизм динамических запросов о типе? Если это так, задайте операции из $$1 3.5 как надстройку над этим механизмом.

8. (*2.5) Определите такой строковый класс, в котором нет никакого динамического контроля, и второй производный от него строковый класс, который только проводит динамический контроль и обращается к первому. Укажите плюсы и минусы такого решения по сравнению с решением,в котором делается выборочный динамический контроль, сравните с подходом, использующим инварианты, как было предложено в $$12.2.7.1. Насколько можно совмещать эти подходы?

9. (*4) Определите класс Storable как абстрактный базовый класс с виртуальными функциями writeout() и readin(). Для простоты допустим, что для задания нужного адресного пространства достаточно строки символов. С помощью класса Storable реализуйте обмен объектами с диском. Проверьте его на объектах нескольких классов по своему усмотрению.

1 0. (*4) Определите базовый класс Persistent с операциями save() и nosave(), который будет проверять,