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 de1ete(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 de1ete(void* space, size t bytes);

С виртуальным деструктором все работает. Если деструктор не виртуальный, в следующем фрагменте будет вызван правильный оператор new и оператор delete базового класса:

Foo* foo = new Bar; delete foo;

Хотя этот фрагмент работает, подобное переопределение перегруженных операторов обычно считается дурным тоном. Во всяком случае в кругу знатоков С++ о таких вещах не говорят. Когда производный класс начинает вмешиваться в управление памятью базового класса, во всей программе начинают возникать непредвиденные эффекты. Если вам захочется использовать несколько стратегий управления памятью в одной иерархии классов, лучше сразу включить нужную стратегию в конкретный производный класс средствами множественного наследования, чем унаследовать ее и потом заявить в производном классе: «Ха-ха, я пошутил».

Аргументы оператора new

Оператор new можно перегрузить так, чтобы помимо размера он вызывался и с другими дополнительными аргументами. Перегрузка лишает вас стандартной сигнатуры void* operator new(size t) , и, если вам этого не хочется, ее придется включить в программу вручную.

#define kPoolSize 4096 struct Pool {

unsigned char* next; Следующий свободный байт

unsigned char space[kPoo1Size];

Poo1() : next(&space[0]) {}

class Foo { public:

void* operator new(size t bytes)

{ return ::operator new(bytes); } void* operator new(size t bytes, Pool* pool)

void* space = poo1->next; poo1->next += bytes; return space;

void f() {

Pool localPool;

Foo* foo1 = new Foo; Использует оператор new по умолчанию Foo* foo2 = new(&1ocalPoo1) Foo; Использует перегрузку

Здесь клиент, а не класс указывает, где следует разместить объект. Показан лишь фрагмент полной стратегии. Например, как оператор delete узнает, откуда была взята память - из глобального пула, используемого оператором new по умолчанию, или настандартного пула, который используется перегруженным оператором new? Впрочем, основная идея проста: предоставить клиенту класса некоторую степень контроля над размещением экземпляров в памяти. Это означает, что способ выделения памяти может выбираться для конкретных объектов и не обязан совпадать для всех экземпляров класса.

Оператор new можно перегружать с любыми новыми сигнатурами при условии, что все они различаются, а первым аргументом каждой перегруженной версии является size t - количество нужных байт. Перегрузки могут быть как глобальными, так и принадлежать конкретным классам. Когда компилятор встречает аргументы между new и именем класса, он подставляет размер в начало списка аргументов и ищет подходящую сигнатуру.

Конструирование с разделением фаз

Эта идиома предложена Джеймсом Коплином (James Coplien), который назвал ее «виртуальным конструктором». Что делает следующий перегруженный оператор new?

class Foo { public:

void* operator new(size t, void* p) { return p; }

На первый взгляд - ничего; пустая трата времени. Но так ли это? Что произойдет в следующем фрагменте?

union U {

Foo foo; Bar bar; Banana banana;

U whatIsThis;

Компилятор С++ не может определить, какой конструктор следует вызывать для whatIsThis - Foo::Foo(), Bar::Bar() или Banana::Banana(). Разумеется, больше одного конструктора вызывать нельзя, поскольку все члены занимают одно и то же место в памяти, но без инструкций от вас не может выбрать нужный конструктор. Как и во многих других ситуациях, компилятор поднимет руки; он сообщает об ошибке и отказывается принимать объединение, члены которого имеют конструкторы. Если вы хотите, чтобы одна область памяти могла инициализироваться несколькими различными способами, придется подумать, как обмануть компилятор. Описанный выше «пустой» конструктор подойдет лучше всего.

unsigned char space[4096];

Foo* whatIsThis = new(&space[0]) Foo;

Фактически происходит то, что в С++ происходить не должно - вызов конструктора. При этом память на выделяется и не освобождается, поскольку оператор new ничего не делает. Тем не менее, компилятор С++ сочтет, что это новый объект, и все равно вызовет конструктор. Если позднее вы передумаете и захотите использовать ту же область памяти для другого объекта, то сможете снова вызвать хитроумный оператор new и инициализировать ее заново.

При создании объекта оператором new компилятор всегда использует двухшаговый процесс:

1 . Выделение памяти под объект.

2. Вызов конструктора объекта.

Этот код запрятан в выполняемом коде, генерируемом компилятором, и в обычных ситуациях второй шаг не выполняется без первого. Идиома виртуального конструктора позволяет надеть повязку на глаза компилятору и обойти это ограничение.

Оперативное изменение типа объекта

Если позднее Foo вам надоест и вы захотите использовать ту же область для Banana, то при наличии у Banana того же перегруженного оператора new вы сможете быстро сменить тип объекта.

Banana* b = new(&space[0]) Banana;

Пуф! Был Foo, стал Banana. Это и называется идиомой виртуального конструктора. Такое решение полностью соответствует спецификации языка.

Ограничения

Применяя эту идиому, необходимо помнить о двух обстоятельствах:

1 . Область, передаваемая оператору new, должна быть достаточна для конструирования класса.

2. Об изменении должны знать все клиенты, хранящие адрес объекта!

Будет весьма неприятно, если вы сменили тип объекта с Foo на Banana только для того, чтобы какой-нибудь клиентский объект тут же вызвал одну из функций Foo.

Уничтожение с разделением фаз

Объект, переданный в качестве аргумента оператору del ete, обычно уничтожается компилятором в два этапа:

1 . Вызов деструктора.

2. Вызов оператора delete для освобождения памяти.

Довольно часто мы качаем головой и говорим: «Хорошо бы вызвать деструктор, но не трогать память». Допустим, вы разместили объект в пуле, а теперь не хотите, чтобы часть локально созданного пула