* законченный учебник и руководство по языку

Вид материала

Подобный материал:

1 ... 26 27 28 29 30 31 32 33 34

частью. Здесь возникают проблемы из-за разных стратегий обработки

ошибок, инициализации, управления памятью. Пример, связанный

с коллизией имен, был приведен потому, что предложенное решение:

введение интерфейсных классов с функциями-переходниками, - имеет

много других применений. Например, с их помощью можно менять

не только имена, но и типы параметров и возвращаемых значений,

вставлять определенные динамические проверки и т.д.

Функции-переходники CCowboy::draw() и WWindow_draw являются

виртуальными, и простая оптимизация с помощью подстановки невозможна.

Однако, есть возможность, что транслятор распознает такие функции

и удалит их из цепочки вызовов.

Интерфейсные функции служат для приспособления интерфейса к

запросам пользователя. Благодаря им в интерфейсе собираются операции,

разбросанные по всей программе. Обратимся к классу vector из $$1.4.

Для таких векторов, как и для массивов, индекс

отсчитывается от нуля. Если пользователь хочет работать с

диапазоном индексов, отличным от диапазона 0..size-1, нужно сделать

соответствующие приспособления, например, такие:

void f()

{

vector v(10); // диапазон [0:9]

// как будто v в диапазоне [1:10]:

for (int i = 1; i<=10; i++) {

v[i-1] = ... // не забыть пересчитать индекс

}

// ...

}

Лучшее решение дает класс vec c произвольными границами индекса:

class vec : public vector {

int lb;

public:

vec(int low, int high)

: vector(high-low+1) { lb=low; }

int& operator[](int i)

{ return vector::operator[](i-lb); }

int low() { return lb; }

int high() { return lb+size() - 1; }

};

Класс vec можно использовать без дополнительных операций, необходимых

в первом примере:

void g()

{

vec v(1,10); // диапазон [1:10]

for (int i = 1; i<=10; i++) {

v[i] = ...

}

// ...

}

Очевидно, вариант с классом vec нагляднее и безопаснее.

Интерфейсные классы имеют и другие важные области применения,

например, интерфейс между программами на С++ и программами на другом

языке ($$12.1.4) или интерфейс с особыми библиотеками С++.

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())

{

// ...

}

// ...

}

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.

На практике иногда приходится извлекать указатель на содержательную

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

Можно, например, передать такой указатель функции, которая ничего

не знает об управляющем классе. Если функция не уничтожает объект,

на который она получила указатель, и если она не сохраняет указатель

для дальнейшего использования после возврата, никаких ошибок быть

не должно. Может оказаться полезным переключение управляющего класса

на другую содержательную часть:

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(); }

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)

/*

Даже в простой функции размещения нужно

выравнивание памяти, чтобы на объект

можно было настроить указатель

произвольного типа

*/

{

union Word { void* p; long double d; long l; }

int x = s + sizeof(Word) - 1;

x -= x%sizeof(Word);

return x;

}

static 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;

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

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;

v[2] = &s;

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

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

}

Если использовать реализацию класса Vector из $$1.4.3, объект

Triangle в этом примере навсегда останется в подвешенном состоянии

(на него нет указателей), если только нет сборщика мусора.

Главное в управлении памятью это - это корректность. Рассмотрим такой

пример:

Blog

* законченный учебник и руководство по языку