Получить таблицу vtable класса без объекта

Question

Я пытаюсь реализовать систему, похожую на the first described here. То есть, (ab) использование модификации vtable для изменения поведения объекта во время выполнения. Это часть моих попыток создать эффективную оболочку типа-типа в проекте C++, над которым я работаю.

пример, вы должны быть в состоянии получить доступ к нему, копируют виртуальные таблицы с использованием memcpy() и this указателя, как например:

void setType(const DataType& newType) 
{ 
    memcpy(this, &newType, sizeof(DataType)); 
} 

Однако, у меня есть проблема с этим методом: у меня нет объекта целевого класса для копирования vtable из и не хотите создавать его, поскольку некоторые типы дорогостоящие для построения.

Есть ли способ получить доступ к vtable, который будет помещен в объект данного класса без объекта этого класса?

Было бы предпочтительнее, если бы оно было несколько портативным, но я в значительной степени смирился с тем, что он является специфичным для компилятора; как таковой, метод GCC/G ++ будет приемлемым, если нет другого варианта. Предположим также, что я заинтересован только в создании этого на довольно стандартных ОС и архитектурах.

Я использую C++ 11, если это поможет.

Редактировать: Я хочу быть совершенно ясным, я знаю, насколько опасен такой тип поведения. Меня больше интересует идея и, возможно, ее узкое приложение в очень контролируемых условиях, чем я в том, что это хорошая идея для программного обеспечения для производства, несмотря на то, что может предложить мое введение.

Answer 1

struct many_vtable { 
    void(*dtor)(void*); 
    void(*print)(void const*,std::ostream&); 
}; 
template<class T>struct tag_t{}; 
template<class T>constexpr tag_t<T> tag = {}; 

template<class T> 
many_vtable const* make_many_vtable(tag_t<T>){ 
    static const many_vtable retval = { 
    // dtor 
    [](void* p){ 
     reinterpret_cast<T*>(p)->~T(); 
    }, 
    // print 
    [](void const*p, std::ostream& os){ 
     os<<*reinterpret_cast<T const*>(p); 
    } 
    }; 
    return &retval; 
} 
struct many { 
    many_vtable const* vtable=nullptr; 
    std::aligned_storage_t<100, alignof(double)> buff; 
    void clear(){if(vtable) vtable->dtor(&buff);vtable=nullptr;} 
    ~many(){ clear(); } 
    many()=default; 
    many(many const&)=delete; // not yet supported 
    many& operator=(many const&)=delete; // not yet supported 

    explicit operator bool()const{return vtable!=nullptr;} 

    template<class T,class...Args> 
    void emplace(Args&&...args){ 
    static_assert(alignof(T) <= alignof(double), "not enough alignment"); 
    static_assert(sizeof(T) <= 100, "not enough size"); 
    clear(); 
    ::new((void*)&buff) T(std::forward<Args>(args)...); 
    vtable=make_many_vtable(tag<T>); 
    } 
    friend std::ostream& operator<<(std::ostream& os, many const&m){ 
    if(!m.vtable) return os; 
    m.vtable->print(&m.buff, os); 
    return os; 
    } 
}; 

Это ручной дизайн vtable. Он может хранить все до 100 байт, выравнивание которых меньше, чем двойное, которое может быть напечатано в потоке.

«Стирание» до более (или разных) операций легко. Например, возможность копирования/перемещения на другое.

Он не нарушает стандарт, и он имеет аналогичные накладные расходы для связанного примера.

many m; 
m.emplace<int>(3); 
std::cout << m << '\n'; 
m.emplace<double>(3.14); 
std::cout << m << '\n'; 

live example.

Это ручные vtables, потому что мы в основном переопределяем концепцию vtable вручную.