Определение класса по объекту
Для существующего экземпляра довольно часто требуется определить его класс. Вроде бы ничего сложного, но в действительности это очень глубокая тема. Помните, что объекты могут создаваться в стеке или в куче, внедряться в другие объекты в виде переменных или базовых классов, а также создаваться производящими функциями. Ниже описано несколько основных решений.
Внедрение указателя на объект класса
Самое очевидное решение - внедрять указатель на Class в любой объект, вложенный или нет.
class Object { // Предок всех реальных классов
protected:
static ObjectClass s_my_class;
Class* my_class; // == &s_my_class;
public:
Object() : my_class(&s_my_class) {}
Class* My_Class() { return my_class; }
};
class Foo : public Object
protected:
static FooClass s_my_class;
public:
Foo() { my_class = &s_my_class; }
};
Все классы порождаются от общего предка Object, в котором определяется протокол для получения объекта Class. Вы имеете полное право использовать одни и те же имена членов на разных уровнях иерархии классов (как это сделано с s_my_class в нашем примере). Компилятор выбирает имя, находящееся в непосредственной области действия. Более того, конструкторы выполняются в порядке «базовый класс/переменные класса/ производные классы», поэтому последний конструктор оставит my_class правильное значение. Эта схема позволяет всегда получить объект Class независимо от
того, сколько выполнялось преобразований типа от производных к базовым классам.
Издержки составляют четыре байта, необходимые для хранения указателя. Виртуальные функции не требуются, поэтому нам не придется добавлять v-таблицу в класс, обходившийся без нее. На избыточное конструирование my_class будут потрачены дополнительные такты процессора, но для большинства приложений это несущественно. Пожалуй, основные издержки сводятся к дополнительному коду, находящемуся в конструкторах.
В более «чистом» варианте указатель на Class задается производящими функциями объекта Class:
class Object {
friend class Class;
private:
Class* my_class;
public:
Class* My_Class() { reutrn my_class; }
};
class Class {
protected:
void SetClass(Object& obj) { obj.my_class = this; }
};
class Foo : public Object { ... };
class FooClass : public Class {
public:
Foo* make()
{
Foo* f = new Foo;
this->SetClass(f);
return f;
}
};
Выглядит получше, поскольку производные от Object классы и не подозревают об этих фокусах… но так ли это? Недостаток этого подхода - в том, что он не работает для экземпляров Foo, объявленных в стеке или вложенных в другие классы в виде структур данных. Перед вами одна из ситуаций, в которых приходится принимать трудное решение: то ли ограничить класс только динамическими экземплярами, то ли искать более сложное решение и без того сложной проблемы.
Существует еще один вариант - управлять выделением памяти и хранить адеса объекта класса прямо над самим объектом в памяти вместо того, чтобы делать его переменной класса предка. Для этого нам понадобятся приемы управления памятью, описанные в части 4.
Внешние структуры данных
Как упоминалось выше, вы также можете создать глобальную коллекцию с парами экземпляр/Class. Все не так скверно, как выглядит на первый взгляд, особенно если информация Class нужна только в процессе отладки и будет исключена в рабочем режиме. Если соблюдать осторожность в реализации, решение также распространяется и на такие вложенные объекты, как стековые переменные или экземпляры, хотя для этого вам понадобится соответствующая поддержка со стороны конструктора и деструктора основного класса.
Нестандартные пространства памяти
Другое решение, рассматриваемое в главах 15 и 16 - физическое разделение объектов по различным пространствам памяти в соответствии с их классом. Оно отличается повышенной сложностью и попросту не работает для вложенных объектов, но зато обладает впечатляющим быстродействием и малым расходом памяти.