Унаследовать функцию с переменным числом параметров

#include <iostream>
#include <utility>
#include <tuple>
 
template <typename F>
struct ArgumentPack;
 
struct Argument
{
public:
    template <typename F, typename Derived>
    void try_to_dispatch(Derived & x, F (Derived::*fp)) const
    {
        auto pack = dynamic_cast<ArgumentPack<F> const *>(this);
        if(pack)
        {
            pack->dispatch(x, fp);
        }
        else
        {
            std::cout << "Viable function not found!\n";
        }
    }
    
    virtual ~Argument()
    { }
};
    
template <typename ...Args>
struct ArgumentPack<void (Args...)>
    : Argument, std::tuple<Args...>
{
    using std::tuple<Args...>::tuple;
 
    template <typename Derived, typename F>
    void dispatch(Derived & x, F (Derived::*fp)) const
    {
        dispatch(x, fp, std::make_index_sequence<sizeof...(Args)>{});
    }
        
private:
    template <typename Derived, typename F, size_t ...Indexes>
    void dispatch(Derived & x, F (Derived::*fp), std::index_sequence<Indexes...>) const
    {
        (x.*fp)(std::get<Indexes>(*this)...);
    } 
};
 
 
class Base
{
public:
    template <typename ...Args>
    void func(Args && ...args)
    {
        Argument const & a = ArgumentPack<void(Args...)>(std::forward<Args>(args)...);
        func(a);
    }
 
protected:
    virtual void func(Argument const &) = 0;
};
 
 
class Derived
    : public Base
{
public:
    void func(int a, char b)
    {
        std::cout << "a: " << a << " b: " << b << std::endl;
    }
 
private:
    void func(Argument const & args) override
    {
        args.try_to_dispatch<void(int, char)>(*this, &Derived::func);
    }
};
 
 
int main()
{
    Base * d1 = new Derived();
 
    d1->func(1, '2'); // dynamic arguments call
    
    Derived * d2 = new Derived();
    
    d2->func(1, '2'); // normal call
    
    
    delete d1;
    delete d2;
}