如何在C ++中伪造可变参数函数模板？

Question

The following code is impossible:

struct poly_base {
    template <typename... ARGS>
    virtual void operator()(ARGS&&... args) = 0;
};

template <typename DATA>
struct poly_derived : public poly_base {
    DATA data;
    template <typename... ARGS>
    void operator()(ARGS&&... args) override {
        data(std::forward<ARGS>(args)...);
    }
};

In what ways can I fake such functionality without relying on the dynamic polymorphism provided by virtual functions? Most importantly, how can I do this without constraining the types of arguments accepted by operator() , except to those supported by the intersection of all DATA ?

If the combinations of ARGS&&... needed were known ahead of time, I'd store the necessary function pointers in poly_base , or declare the necessary pure virtual functions. But how can I do this without constraining the argument types?

Were such a thing possible, I'd expect the compiler to generate a vtable with the union of all poly_base::operator() overloads invoked in all translation units for each DATA with which poly_derived is instantiated. How can I fake such a thing myself using variadic templates, function pointers, and template variables?

Clarification: I don't want to type-erase ARGS . They should be known to the caller and to the callee. I only want to erase DATA .

Answer 1

The answer is simple. You don't.

The set of arguments that a single type supports in C++ is Halt-complete; you couldn't even do this for a single DATA type where you type erase all valid arguments in a known table.

On top of that, the set of types derived from a class is not available anywhere with dynamic linking, it is not even known at link time.

Answer 2

使用C可变参数可以解决ABI问题，但是我不知道它是否可以与关键字virtual一起使用。