RTTI vs Шаблонная магия?

Question

[Monnoroch]

Есть структура классов:

class IObject {
public:
	virtual bool Method() = 0;
	template<class T> T * As() { return (T*)this; }	// да-да, не dynamic_cast.
}

class Object1 : public IObject {
	public: virtual bool Method() { /* some logic */ }
}

class Object2 : public IObject {
	public: virtual bool Method() { /* some logic */ }
}

И есть класс

class NamedObject : public IObject {
public:
	NamedObject(const std::string& nm, IObject * o) : name(nm), obj(o) {}

	virtual bool Method() { return obj->Method(); }
	std::string& Name() { return name; }
	IObject * Object() { return obj; }
	
private:
	IObject * obj;
	std::string name;
}

И есть некоторая обертка на RTTI, которая призвана сделать так, что NamedObject может восприниматься, как лежащий под ним обьект:

template<typename T> 
inline bool isA(IObject * obj)
{
	return dynamic_cast<T*>(obj) != null ||
		(isA<NamedObject>(obj) && isA<T>(obj->As<NamedObject>()->Object()));
}

template<> 
inline bool isA<NamedObject>(IObject * obj)
{
	return dynamic_cast< NamedObject* >(obj) != null;
}

И есть некое чувство, что эту схему можно реализовать без RTTI, на шаблонах и множественном наследовании.

Код, в некотором смысле, библиотечный, созданием всяческих обьектов данной иерархии занимается фабрика, так что жуткая шаблонная магия приемлема.


Если кто желает поломать голову и имеет большой C++ скилл, приглашаю обсудить возможные варианты.

Comments

[Rowdy Ro]

спасибо кнопки F5…

return dynamic_cast(obj) != null; -сижу и думаю, что за магия у вас…

[Monnoroch]

Было без пробелов рядом с угловыми скобками, и почему-то парсер это сьел.

[sdevalex]

Запятая пропущена.

NamedObject(const std::string& nm, IObject * o) : name(nm) obj(o) {}

Answer 1

[NYM]

Попытка написания своей компонентной модели на C++
Пойдет?

Comments

[Monnoroch]

Статья потрясная, спасибо большое! Однако, во-первых, мне она пока тяжело дается, а во-вторых, учитывая то, что было во-первых, у меня не получилось четко выделить ответ на мой вопрос из нее.

Answer 2

[Ryadovoy]

Из описания непонятно какая конечная цель, что именно Вы хотите сделать?

Comments

[motl]

у меня такой же вопрос

Answer 3

[cencio]

если правильно понял, что пробуете сделать, то ciaranm.wordpress.com/2010/05/24/runtime-type-checking-in-c-without-rtti/ тоже самое, но акуратней написаное и в 2 вариантах, вам нужен последний(в конце статьи), грубо говоря там для каждого типа генерится уникальное целое число, по нему и происходит проверка типа.

Answer 4

[gribozavr]

В LLVM и Clang используется нечто подобное. Вот заголовок, реализующий isa и dyn_cast llvm.org/docs/doxygen/html/Casting_8h_source.html
Для поддержки этого в ваших классах нужно реализовать два метода classof(), например clang.llvm.org/doxygen/Comment_8h_source.html

Для поддержки использования объектов-обёрток реализуй те специализацию шаблона simlify_type.

Answer 5

[motl]

Вы хотите работаете с объектами через указатель на базовый класс IObject и хотите реализовать isA при помощи шаблонов. Это невозможно, так как инстанцирование шаблонов происходит в compile-time, а инициализация указателей на IObject происходит в run-time. IObject передается по указателю в качестве аргумента в конструктор NamedObject, поэтому тип obj известен только в run-time и без RTTI тут не обойтись.

Comments

[Monnoroch]

Для начала, я думал о:

template<class T>
class NamedObject : public IObject, public T {}

И о том, чтобы сделать NamedObject не оберткой, а наследником и через это избавиться от своей (iaA) обертки на RTTI, и пользоваться только dynamic_cast. Минус в порождении кучи классов NamedObject, и заодно в этом случае затруднительно так легко проверить, что класс является каким-то из этих NamedObject, так что обертка опять возвращается. В общем и целом, я просто хочу найти более элегантное решение, буде такое существует.

[Monnoroch]

Естественно, я понимаю, что в любом случае придется применять dynamic_cast, под «без RTTI», я имел ввиду не вообще «без RTTI», а без своих надстроек над ним, ну или хотя бы с максимально простыми надстройками, или наиболее красивыми. В общем, это чисто исследовательский и эстетический интерес, с точки зрения работоспособности текущая схема вполне устраивает.

Answer 6

[NYM]

Берем идею, упомянутую ссылкой в постах выше и делаем для нее пример:

#include <iostream>

class TypeIdGenerator
{
public:
	template <typename T>
	static const int GetId()
	{
		static const int Id = GetNextId();
		return Id;
	}
private:
	static int GetNextId()
	{
		static int Id = 0;
		return Id++;
	}
};

struct ICast
{
	virtual ~ICast()
	{
	}
	virtual void const* Cast(int id) const = 0;
	virtual void * Cast(int id) = 0;
};

template <typename T>
class CastImpl
	: public T
{
public:
	virtual void const* Cast(int id) const
	{
		return id == TypeIdGenerator::GetId<T>() ? this : 0;
	}
	virtual void * Cast(int id)
	{
		return id == TypeIdGenerator::GetId<T>() ? this : 0;
	}
};

template <typename T>
T* MyCast(ICast *obj)
{
	return reinterpret_cast<T *>(obj->Cast(TypeIdGenerator::GetId<T>()));
}

template <typename T>
T const* MyCast(ICast const *obj)
{
	return reinterpret_cast<T const *>(obj->Cast(TypeIdGenerator::GetId<T>()));
}

class A
	: public ICast
{
public:
	void mtd() const
	{
		std::cout << __FUNCTION__ << std::endl;
	}
};

int main()
{
	ICast const &obj = CastImpl<A>();
	A const *a = MyCast<A>(&obj);
	if (a)
		a->mtd();
	return 0;
}

Для работы такого каста нужно наследование от некого интерфейса, но не будем забывать, что dynamic_cast тоже не бесплатно работает, он требует плату виртуальностью, т.е. ваш класс должен хоть что-то содержать виртуальное, хоть деструктор, но тип должен быть полиморфным.

Comments

[Monnoroch]

Ваша реализация не обработает наследование, то есть кастование к предку. То есть вы определяете принадлежность классу, а не вложенность унаследованного класса в базовый. В коде вопроса, конечно, все обьекты отнаследованы от интерфейса, но они могут и друг от друга быть наследованы.

[Monnoroch]

Но на этой волне я придумал некое решение с TypeIdGenerator:
надо на каждый класс завести TypeList его базовых классов и можно сделать шаблонную функцию, проверяющую для каждого T из этого списка id == TypeIdGenerator::GetId().
Печаль в том, что либо предков надо указывать вручную, либо реализовывать механизм наследования от всех типов из тайплиста, описанный в вашей статье.

[NYM]

Сделать нормальную альтернативу dynamic_cast получится, но усилий надо будет приложить некотрое количество.
dynamic_cast — С++ альтернатива COM'вому QueryInterface'у. Получается вы или используетет C++ механизм (dynamic_cast), или рисуете свою модель на основе интерфейсов. Можно только RTTI сделать как это когда-то было свое RTTI в MFC на куче макросов.
Вопорс: а в чем проблема с использованием RTTI?

Answer 7

[AxisPod]

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

Я у себя не стал отказываться от наследования, ибо шаблонная магия даже если после кучи извращений и чего-нить даст, то здесь потеря времени разработки, высокая сложность кода.

Не знаю что конкретно вы хотите. Так что в общем попытаюсь рассказать свой подход. Реализовал элементарный механизм. Есть базовый интерфейс, пустой. От него наследуются все остальные. Динамическая библиотека реализует 4 обязательных метода CreateInstance, DestroyInstance — для создание и удаления объектов и CreateEnumerator, DestroyEnumerator — для создания перечисления доступных объектов внутри библиотеки. Сделал простенький менеджер библиотек, фабрику и объект по типу shared_ptr, только с завязкой на библиотеку. В итоге используется простой код

Instance<IInterface> obj = mgr->CreateInstance<IInterface>("identificator");

CreateInstance использует dynamic_cast для приведения к нужному, в случае ошибки кидает исключение.

Answer 8

[AxisPod]

А вообще все же интересует, зачем своя реализация простого RTTI, которое и так уже есть.

Answer 9

[Владислав]

Вот вам еще вариант:
pastebin.com/RZAY789w

умеет:

typedef std::unique_ptr< IObject > ptr;
 
ptr p = CreateObject< Object3 >();
assert( FastObjectCast< Object3 >( p.get() ) );
assert( FastObjectCast< Object1 >( p.get() ) ); // Object3 inherits Object1
assert( !FastObjectCast< INamedObject >( p.get() ) ); // p is unnamed Object3
 
ptr q = CreateObject< Object3 >( "some name" );
assert( FastObjectCast< Object3 >( q.get() ) );
assert( FastObjectCast< Object1 >( q.get() ) ); // Object3 inherits Object1
assert( FastObjectCast< INamedObject >( q.get() ) ); // p is named Object3

INamedObject наследуется также реализует IObject
FastObjectCast семантически эквивалентен dynamic_cast, но раз в 10 быстрее (dynamic_cast тоже можно использовать).

p.s.
Так нельзя делать:

template<class T> T * As() { return (T*)this; }

Нужно использовать static_cast, т.к. после каста указатель может поменять значение на пару байт (это происходит из-за множественного наследования, если оно есть в иерархии).