используя RTTI в C ++ для приведения объекта к правильному типу

Основываясь на первом ответе Боуи Оуэна, я понял, что хотя указанные типы, вероятно, не будут производными от одного и того же класса (это библиотека), я мог бы заставить это произойти:

struct ObjectProxyBaseType {
virtual ~ObjectProxyBaseType() {}
};

template <class T>
class ObjectProxyType: public ObjectProxyBaseType, public T {
public:
// allow construction via parameters
template <typename... Args>
ObjectProxyType(Args &&... args): T(std::move(args)...) {}

// or construction via copy constructor
ObjectProxyType(T *t): T(*t) {}

virtual ~ObjectProxyType() {}
};

Таким образом, если у меня есть класс Child, я могу создать экземпляр ObjectProxyType<Child>, что заставляет его также наследовать ObjectProxyBaseType, Остальная часть кода следует предложению Боуи:

class ObjectProxy: public Object {
protected:
ObjectProxyBaseType *instance;
public:
template <typename T>
ObjectProxy(ObjectProxyType<T> *i) {
instance = i;
}

template <typename T>
ObjectProxy(T *value) {
instance = new ObjectProxyType<T>(value);
}template <typename T>
T *castTo() const {
return dynamic_cast<T *>(instance);
}
};

И пример кода, который работает:

int main() {
std::list<Object *> stack;
stack.push_back(new ObjectProxy(new Child(1, 2)));
callFn<Child>(stack, doSomething);

stack.push_back(new ObjectProxy(new Child(5, 6)));
callFn<Parent>(stack, doSomething);
}

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

Итак, скажем, эти иерархии следующие:

класс Parent1
класс Child1: public Parent1
класс Child11: общедоступный Child1
...
класс Parent2
класс Child2: общедоступный Parent2
...

Затем вы строите класс держателя. Это немного сложно по простой причине — мой компилятор не поддерживает параметры шаблона по умолчанию для функций, поэтому я использую вспомогательные структуры для включения SFINAE.

Этот класс должен иметь возможность хранить объекты, принадлежащие всем иерархиям (через указатель базового класса).

class TypeHolder
{
template<class T, class E=void>
struct GetHelper
{
static T* Get(const TypeHolder* th) { return nullptr; }
//you can actually add code here to deal with non-polymorphic types through this class as well, if desirable
};

template<class T>
struct GetHelper<T, typename std::enable_if<std::is_polymorphic<T>::value, void>::type>
{
static T* Get(const TypeHolder* th)
{
switch(th->type)
{
case P1: return dynamic_cast<T*>(th->data.p1);
case P2: return dynamic_cast<T*>(th->data.p2);
//and so on...
default: return nullptr;
}
}
};

template<class T, class E=void>
struct SetHelper
{
static void Set(T*, TypeHolder* th) { th->type = EMPTY; }
};

template<class T>
struct SetHelper<T, typename std::enable_if<std::is_polymorphic<T>::value, void>::type>
{
static void Set(T* t, TypeHolder* th)
{
th->data.p1 = dynamic_cast<Parent1*>(t);
if(th->data.p1) { th->type = P1; return; }

th->data.p2 = dynamic_cast<Parent2*>(t);
if(th->data.p2) { th->type = P2; return; }

//...and so on

th->type = EMPTY;
}
};

public:
TypeHolder(): type(EMPTY) { }

template<class T>
T* GetInstance() const
{
return GetHelper<T>::Get(this);
}

template<class T>
void SetInstance(T* t)
{
SetHelper<T>::Set(t, this);
}

private:
union
{
Parent1* p1;
Parent2* p2;
//...and so on
} data;

enum
{
EMPTY,
P1,
P2
//...and so on
} type;
};

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

Теперь все, что вам нужно сделать, это изменить ваши классы просто немного немного 🙂

class ObjectProxyBase
{
public:
virtual const TypeHolder& GetTypeHolder() const = 0;
};

template<class T>
class ObjectProxy: public Object, public ObjectProxyBase
{
T* instance;

static TypeHolder th; //or you can store this somewhere else, or make it a normal (but probably mutable) member
public:
ObjectProxy(T* t): instance(t) { }

T* getInstance() const { return instance; }

const TypeHolder& GetTypeHolder() const { th.SetInstance(instance); return th; }

//... and the rest of the class
};

template<class T>
TypeHolder ObjectProxy<T>::th;

Я надеюсь, что этот код на самом деле правильный, так как я в основном набрал его в окне браузера (мой использовал разные имена).

А теперь финальная часть: функция.

template <typename C>
void callFn(std::list<Object *> &stack, std::function<void (C*)> fn) {
Object *value = stack.front();
stack.pop_front();

ObjectProxyBase *proxy = dynamic_cast<ObjectProxyBase *>(value);
if (proxy == nullptr) {
throw std::runtime_error("dynamic cast failed");
}

C* heldobj = proxy->GetTypeHolder().GetInstance<C>(); //I used to have a dynamic_cast here but it was unnecessary
if (heldobj == nullptr) {
throw std::runtime_error("object type mismatch");
}

fn(heldobj);
}

Вам нужно только использовать этот подход для иерархий, и вы все равно можете использовать dynamic_cast прямо к ObjectProxy<C>*[/ NOEDIT] в других случаях (по сути, вы захотите попробовать оба и посмотреть, если это удастся).

Я надеюсь, что это будет хоть немного полезно.