Как определить тип объекта из таблицы виртуальных методов?

typedef void (*FunctionPtr)();
 
bool check_equals(Ex const *left, Ex const *right)
{
    FunctionPtr* vtable1 = *(FunctionPtr**)(&left);
    FunctionPtr* vtable2 = *(FunctionPtr**)(&right);
    bool b = (size_t*)vtable1[0] == (size_t*)vtable2[0];
    return b;
}

bool check_equals(Ex const *left, Ex const *right)
{
    FunctionPtr* vtable1 = *(FunctionPtr**)(&left);
    FunctionPtr* vtable2 = *(FunctionPtr**)(&right);
    bool b = (size_t*)vtable1[0] == (size_t*)vtable2[0];
    return b;
}

bool check_equals(Ex const *left, Ex const *right)
{
    return typeid(*left) == typeid(*right);
}

#include <iostream>
#include <memory>
 
// --- отсутствует метод клонирования
struct IBase
{
    virtual ~IBase(){}
    virtual const char* GetName()const = 0;
    void AboutMe() { std::cout << GetName()<<'\n'; }
};
 
struct Der: IBase 
{
    Der()
    {
        std::cout<<"[ctor] "<< GetName()<<'\n'; 
    }
    
    Der(const Der& rhs)
    {
        std::cout<<"[copy] "<< GetName()<<'\n'; 
    }
    
    const char* GetName()const { return "my name is Der"; }
};
struct Bar: IBase 
{
    Bar()
    {
        std::cout<<"[ctor] "<< GetName()<<'\n'; 
    }
    
    Bar(const Bar& rhs)
    {
        std::cout<<"[copy] "<< GetName()<<'\n'; 
    }
    
    const char* GetName()const { return "my name is Der"; }
};
 
// --- тем не менее, мы хотим иметь возможность
// клонировать наследников
//
// для этого будем использовать специальный враппер
// который используя паттерн type-erasure
// сможет "запоминать" фактический тип захваченного им ресурса
// и выполнять различные действия.
//
// в частности становится возможным выполнить клонирование объектов
// независимо от того, 
// есть ли у них метод clone в базовом интерфейсе
 
 
template<class T> struct wrapper
{
    typedef std::shared_ptr<IBase>
        res;
    
    struct ihelp
    {
        virtual res clone(const res& obj)const = 0;
    };
    
    
    // не должен иметь данных-членов
    // но для упрощения кода все проверки удалены
    template<class U> struct help
    {
        virtual res clone(const res& obj)const 
        {
            // параметр U совпадает с типом ресурса
            // поэтому статический каст от базы к наследнику 
            // гарантированно возможен
            const auto& der 
                = std::static_pointer_cast<U>(obj);
            
            return std::make_shared<U>(*der);
        }
    };
    
    template<class U, class... Args>
    void emplace(Args&& ...args)
    {
        // при захвате ресурса
        // мы не только конструируем сам ресурс
        m_res = std::make_shared<U>( std::forward<Args>(args)... );
        
        // но и запоминаем его фактический тип
        new (m_help) help<U>;
    }
    
    T* operator->() { return m_res.get(); }
    
    res copy()const
    {
        const auto* cloner 
            = reinterpret_cast<const ihelp*>(m_help);
        return cloner->clone(m_res);
    }
    
    res m_res;
    
    char m_help[ sizeof(ihelp) ];
    
};
 
void test(const wrapper<IBase>& obj)
{
    // IBase не умеет клонирование
    // однако wrapper запомнил 
    // фактический тип ресурса
    // поэтому может запустить конструктор копии наследника
    auto copy = obj.copy();
    copy->AboutMe();
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    wrapper<IBase> der;
    
    // захватываем ресурс
    // враппер запоминает фактический тип ресурса 
    // при помощи специального хэлпера
    der.emplace<Der>();
    der->AboutMe();
 
    test(der);
}