Перегрузка |
13 |
операторов |
|
управления |
|
памятью |
Давайте отдохнем от указателей и поговорим об управлении памятью. Говорят, типичный программист на С++ (если он вообще существует) тратит 50 процентов своего рабочего времени на управление памятью. Когда удалять объект? Как гарантировать, что старый адрес объекта нигде не останется после его уничтожения? Как добиться приличного быстродействия от популярных классов со стандартной схемой управления памятью, которую компилятор использует на все случаи жизни? В отличие от таких языков, как SmallTalk и Lisp, стандартные средства С++ не окажут вам особой помощи в этом вопросе. К счастью, в С++ имеется несколько прекрасных «лазеек»; тот, кто сумеет найти эти обходные пути, при необходимости всегда сможет добиться хорошего быстродействия, а по возможностям управления памятью — осмелюсь ли я произнести это вслух? — его программа не уступит SmallTalk.
Управление памятью — одна из самых мистических тем в компьютерных технологиях; то, над чем бьются выдающиеся умы в великих университетах. Я не претендую на глубокое освещение темы в целом. В оставшейся части книги мы посмотрим, как синтаксис и идиомы С++ помогают построить основу для подключения тех алгоритмов и структур данных, которые вы захотите реализовать. Тем не менее, даже краткие примеры из этой и следующей главы могут пригодиться на практике, если ваша задача не отличается особой сложностью.
Глава начинается с самого важного — перегрузки операторов new и delete. Затем мы рассмотрим несколько упрощенных, но очень полезных приемов управления памятью в С++. В последующих главах описываются нетривиальные методы, основанные на идеях этой главы.
Перегрузка операторов new и delete
Многие удивляются тому, что операторы new и delete можно перегружать, как и все остальные операторы. Понять, как это делается, проще всего на примере.
Простой список свободной памяти
Рассмотрим простой пример. Оператор delete включает освобождаемые блоки в список свободной памяти. Оператор new сначала пытается выделить блок из списка и обращается к глобальному оператору new лишь в том случае, если список свободной памяти пуст.
class Foo { private:
struct FreeNode { FreeNode* next;
};
static FreeNode* fdFreeList;
194
public:
void* operator new(size_t bytes)
{
if (fgFreeList == NULL)
return ::operator new(bytes); FreeNode* node = fgFreeList; FgFreeList = fgFreeList->next; return node;
}
void operator delete(void* space)
{
((FreeNode*)space->next = fgFreeList; fgFreeList = (FreeNode*)space;
}
};
Как вы вскоре убедитесь, приведенный фрагмент неполон, однако он демонстрирует общие принципы перегрузки операторов new и delete для конкретного класса. Оператор new получает один аргумент, объем выделяемого блока, и возвращает адрес выделенного блока. Аргументом оператора delete является адрес освобождаемой области. Не пытайтесь объявлять их виртуальными; компилятор лишь посмеется над вами. При вызове оператора new компилятор точно знает, с каким классом он имеет дело, поэтому v-таблица ему не нужна. При вызове оператора delete деструктор определяет, какому классу этот оператор должен принадлежать. Если вы хотите гарантировать, что будет вызываться оператор delete производного класса, то виртуальным нужно сделать деструктор, а не оператор delete. Перегрузки будут унаследованы производными класса Foo, поэтому это повлияет и на процесс выделения/освобождения памяти в них. На практике нередко создается абстрактный базовый класс, который не делает почти ничего (как и в приведенном примере) и используется только для создания классов с данной схемой управления памятью.
class Bar : public Baseclass, public Foo { ... };
Здесь Bar наследует все базовые характеристики типа Baseclass, а нестандартное управление памятью — от Foo.
Ограничения минимального размера
Перед тем как хвататься за компилятор, необходимо привести в порядок показанный фрагмент. Вопервых, предполагается, что экземпляр Foo содержит по крайней мере не меньше байт, чем Foo::FreeNode*. Для классов вроде нашего, не имеющего переменных и виртуальных функций, этого гарантировать нельзя. Он будет иметь определенный размер (во многих компиляторах — два байта), чтобы объекты обладали уникальным адресом, но по количеству байт он может быть меньше указателя на FreeNode. Мы должны гарантировать, что размер Foo не меньше размера указателя — для этого нужно включить в него v-таблицу или хотя бы переменные, дополняющие его до размера указателя.
Производные классы с добавленными переменными
Другая проблема заключается в том, что приведенный фрагмент не работает с производными классами, в которых добавляются новые переменные. Рассмотрим следующую иерархию классов.
class Bar : public Foo { private:
int x;
};
Каждый экземпляр Bar по крайней мере на пару байт больше, чем экземпляр Foo. Если удалить экземпляр Foo, а затем попытаться немедленно выделить память для экземпляра Bar… караул! Выделенный блок оказывается на ту же на пару байт короче. Возможное силовое решение — сделать оператор new достаточно умным для того, чтобы он перехватывал только попытки выделения правильного количества байт. Позднее будут рассмотрены и более изящные решения.
195
class Foo { public:
void* operator new(size_t bytes)
{
if (bytes != sizeof(Foo) || fgFreeList == NULL) return ::operator new(bytes);
FreeNode* node = fgFreeList; FgFreeList = fgFreeList->next; Return node;
}
};
Мы избавились лишь от проблем, связанных с выделением памяти. Процесс освобождения необходимо изменить в соответствии с этой стратегией. Альтернативная форма оператора delete имеет второй аргумент — количество освобождаемых байт. На первый взгляд кажется, что из затруднений появился изящный выход:
class Foo { public:
void* operator new(size_t bytes); // См. Выше void operator delete(void* space, size_t bytes)
{
if (bytes != sizeof(Foo)) ::operator delete(space);
((FreeNode*)space)->next = fgFreeList; fgFreeList = (FreeNode*)space;
}
};
Теперь в список будут заноситься только настоящие Foo и производные классы, совпадающие по размеру. Неплохо, но есть одна проблема. Как компилятор поведет себя в следующем фрагменте?
Foo* foo = new Bar;
delete foo; // Какой размер будет использован компилятором?
Bar больше Foo, поэтому Foo::operator new перепоручает работу глобальному оператору new. Но когда подходит время освобождать память, компилятор все путает. Размер, передаваемый Foo::operator delete, основан на догадке компилятора относительно настоящего типа, а эта догадка может оказаться неверной. В данном случае мы сказали компилятору, что это Foo, а не Bar; компилятор ухмыляется и продолжает играть по нашим правилам. Чтобы справиться с затруднениями, необходимо знать точную последовательность уничтожения, возникающую в операторах вида delete foo;. Сначала вызываются деструкторы, начиная с производного класса, и далее вверх по цепочке. Затем оператор delete вызывается кодом, окружающим деструктор производного класса. Это означает, что проблема возникает только для невиртуальных деструкторов. Если деструктор является виртуальным, аргумент размера в операторе delete всегда будет правильным — 2438-й довод в пользу применения виртуальных деструкторов, если только у вас не находится действительно веских причин против них.
Рабочий класс списка свободной памяти
Учитывая все сказанное, следующий фрагмент всегда будет правильно работать на компиляторах, использующих v-таблицы.
class Foo { private:
struct FreeNode { FreeNode* next;
};
196
static FreeNode* fdFreeList; public:
virtual ~Foo() {}
void* operator new(size_t bytes)
{
if (bytes != sizeof(Foo) || fgFreeList == NULL) return ::operator new(bytes);
FreeNode* node = fgFreeList; FgFreeList = fgFreeList->next; return node;
}
void operator delete(void* space, size_t bytes)
{
if (bytes != sizeof(Foo))
return ::operator delete(space); ((FreeNode*)space)->next = fgFreeList; fgFreeList = (FreeNode*)space;
}
};
Указатель v-таблицы гарантирует, что каждый Foo по крайней мере не меньше указателя на следующий элемент списка (FreeNode*), а виртуальный деструктор обеспечивает правильность размера, передаваемого оператору delete.
Повторяю: рассмотренная схема управления памятью не предназначена для практического применения (встретив производный класс, она собирает вещи и отправляется домой). Она лишь демонстрирует некоторые базовые принципы перегрузки операторов new и delete.
Наследование операторов new и delete
Если перегрузить операторы new и delete для некоторого класса, перегруженные версии будут унаследованы производными классами. Ничто не помешает вам снова перегрузить new и/или delete в одном из этих производных классов.
class Bar : public Foo { public:
virtual ~Bar(); // Foo::~Foo тоже должен быть виртуальным void* operator new(size_t bytes);
void operator delete(void* space, size_t bytes);
};
С виртуальным деструктором все работает. Если деструктор не виртуальный, в следующем фрагменте будет вызван правильный оператор new и оператор delete базового класса:
Foo* foo = new Bar; delete foo;
Хотя этот фрагмент работает, подобное переопределение перегруженных операторов обычно считается дурным тоном. Во всяком случае в кругу знатоков С++ о таких вещах не говорят. Когда производный класс начинает вмешиваться в управление памятью базового класса, во всей программе начинают возникать непредвиденные эффекты. Если вам захочется использовать несколько стратегий управления памятью в одной иерархии классов, лучше сразу включить нужную стратегию в конкретный производный класс средствами множественного наследования, чем унаследовать ее и потом заявить в производном классе: «Ха-ха, я пошутил».