Размещение v-таблицы в начале объекта приводит к тому, что принадлежащие C реализации виртуальных функций, объявленных в A, останутся доступными, но будут иметь те же смещения, что и для A. Работая с C*, компилятор знает полную структуру всего объекта и может обращаться к членам A, B и C на их законных местах. Но когда компилятор выполняет преобразование ко второму или одному из следующих классов в списке множественного наследования, адрес изменяется - клиентский код будет считать, что он имеет дело с B.

На самом деле v-таблиц две. Одна находится в начале объекта и содержит все виртуальные функции, первоначально объявленные в A или C, а другая - в начале компонента B и содержит виртуальные функции, объявленные в B. Это означает, что преобразование типа от производного к базовому классу в С++ может при некоторых обстоятельствах породить указатель на середину объекта (по аналогии с указателями на переменные класса, о которых говорилось выше). Кроме того, в С++ открывается возможность дурацких фокусов:

C* anotherC = C*(void*(B*(c))); anotherC->MemberOfC();

Видите, в чем проблема? Преобразование B*(c) смещает указатель. Затем он преобразуется к типу void*. Далее следует обратное преобразование к C* - и наша программа будет уверена, что C начинается с неверного адреса. Без преобразования к void* все работает, поскольку компилятор может опеределить смещение B* в C*. В сущности, преобразование от base* к derived* (где base - базовый, а derived - производный класс) выполняется каждый раз, когда клиент вызывает виртуальную функцию B, переопределенную в C. Но когда происходит преобразование от void* к C*, компилятор лишь наивно полагает, что программист действует сознательно.

Запомните: каждый программист на С++ за свою карьеру проводит как минимум одну бессонную ночь, пытаясь понять, почему его объект бредит. Потом приходит какой-нибудь гуру, с ходу ставит диагноз синдром класс-void-класс - притом так, чтобы слышали окружающие смехом. Впрочем, я отклонился от темы.

и разражается злорадным

Виртуальные базовые классы

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

class Base {...};

class A : virtual public Base {...}; class B : virtual public Base {...}; class Foo : public A, public B {...};

Тьфу. Компилятору так стыдно, что Base приходится реализовывать как виртуальный базовый класс, что он прячет его как можно дальше, под Foo. A и B содержат указатели на экземпляр Base да, все верно, указатели, то есть непосредственные адреса в памяти. Вы не имеете доступа к этим указателям и, следовательно, не сможете обновить их при перемещении объекта в памяти.

Base

Указатель на переменную класса

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

class Foo { private:

int x; public:

static int& Foo::*X() { return &Foo::x; }

Foo f = new Foo; Создать экземпляр

int& Foo::*pm = Foo::X(); Вычислить смещение int

int& i = f->*pm; Применить смещение к экземпляру

Функция X() возвращает не ссылку на int, а смещение некоторого int в экземплярах класса Foo. Функция Foo::X() объявлена статической, поскольку относится не к конкретному экземпляру, а к классу в целом. Команда return &Foo ::x; определяет смещение конкретной переменной, x. В строке int& Foo::*pm = Foo::X(); объявляется переменная pm, которая содержит смещение переменной int класса Foo. Она инициализируется смещением, полученным от Foo::X(). Наконец, в строке int& i = f->*pm; смещение применяется к конкретному экземпляру для вычисления адреса конкретного int. Обратите внимание: значение pm само по себе бесполезно до тех пор, пока вы не примение его к объекту.

Все эти int& с таким же успехом можно заменить на int*. В любом случае все завершается косвенным получением адреса некоторой части объекта так, словно вы получили явный адрес переменной класса. Указатели на члены классов также могут применяться для косвенных ссылок на функции, а не на переменные класса, но это не относится к нашей теме - управление памятью. К тому же я не хочу взваливать на себя лишнюю головную боль.

pm = Foo::XO F->*pm

-t>

vtable

Последствия

Все сказанное обладает фундаментальными последствиями для управления памятью. Чтобы переместить объект в памяти, вам придется проследить за тем, чтобы перемещался вмещающий объект верхнего уровня, а не некоторый вложенный объект, адрес которого у вас имеется. Более того, при перемещении объекта придется обновлять все указатели - не только на сам объект, но и на все вложенные объекты и базовые классы.

Если вы хотите узнать, существуют ли ссылки на некоторый объект, придется искать указатели не только на начало объекта, но и на все его переменные и базовые классы.

Поиск указателей

Итак, теперь мы знаем, с какими разными указателями нам придется иметь дело. Как же отыскать их все? Чтобы переместить объект, нам придется обновить все указатели на него. Чтобы понять, доступен ли объект, придется собрать все указатели.

Специализированные пространства памяти для указателей

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

содержимое (то есть создать итерацию для набора умных указателей). В классах все эти *-указатели заменяются дескрипторами или ссылками на умные указатели, поскольку сами указатели должны находиться в отдельном пространстве. В следующем фрагменте программы P и H представляют собой стандартные указатели и дескрипторы соответственно, за исключением того, что P сохраняет экземпляры указателей в специальном пространстве памяти. Эта методика хорошо подойдет и для невидимых указателей, если для их сохранения в надежном, хорошо известном месте будет использована одна из методик нестандартных пространств памяти. Указатель P обычно является ведущим, но это не обязательно.

template <c1ass Type> class P { Указатель private:

Type* pointee; public:

void* operator new(size t);

void operator de1ete(void*);

Использует специальное пространство памяти Использует специальное пространство памяти

Все для умных указателей

template <c1ass Type> class H { Дескриптор private:

P<Type>* ptr; public:

Все для дескрипторов

class Foo { private:

P<Bar>& bar; Ссылка на умный указатель на Bar ИЛИ

H<Bar>& bar; Дескриптор Bar

В первом варианте мы храним ссылку на умный указатель, причем сам указатель, вероятно, хранится где-то в другом месте. Во втором варианте мы используем идиому дескриптора - умного указателя на умный указатель. Сам дескриптор находится в объекте, но указатель, на который он ссылается, - в специальном пространстве указателей, используемом операторами new и delete класса P. Если пространство указателей будет реализовано толково, все указатели можно будет перебирать прямо из него. В это случае задача перемещения объекта несколько упрощается (хотя и не становится простой), поскольку все указатели на него можно найти в пространстве указателей. Полная реализация этой методики приведена ниже в этой главе.

Скрытые коллекции указателей

Другое возможное решение - поддержать скрытые коллекции умных указателей. template <c1ass Type>

class P {

private:

static P<Type>* head; static P<Type>* tail; P<Type>* next;

P<Type>* previous;

Type* pointee;

Начало списка MP Конец списка

Следующий элемент списка Предыдущий элемент списка