Templates 使用可变模板将std:：vector中存储的void*转换为函数参数

我创建了一个MemberFunctionWrapper模板类，用于存储函数及其参数类型。它有一个调用方法，该方法接受void*向量，并在调用函数之前将其转换为函数调用所需的参数类型

我的问题是包装器只能接受固定数量的函数参数 （_arg0，_arg1）。
我想让类接受任意数量的函数参数（arg0、arg1、arg2…argX），我如何实现这一点

提前谢谢

class Foo
{
public:
    void foo( int a, const string& b );
};

template< class _obj, class _function, class _arg0, class _arg1 >
class MemberFunctionWrapper
{
    const _function m_memberfunction;

public:
    MemberFunctionWrapper( _function memFn )
        : m_memberfunction( memFn )
    { }

    void call( std::shared_ptr<void>& obj,
               const std::vector<std::shared_ptr<void>>& args )
    {
        m_memberfunction( *static_cast< _obj* >(obj.get()),
                          *static_cast< _arg0* >(args.at( 0 ).get()),
                          *static_cast< _arg1* >(args.at( 1 ).get()) );
    }

};

int main()
{
    std::shared_ptr<int> i( new int( 88 ) );
    std::shared_ptr<string> s( new string( "hello" ) );
    std::shared_ptr<Foo> foo( new Foo );

    std::shared_ptr<void> iVoid = std::static_pointer_cast< void >(i);
    std::shared_ptr<void> sVoid = std::static_pointer_cast< void >(s);
    std::shared_ptr<void> fooVoid = std::static_pointer_cast< void >(foo);

    MemberFunctionWrapper
    <
        Foo,
        decltype(std::mem_fn( &Foo::foo )),
        int,
        string
    > wrapper( &Foo::foo );

    wrapper.call( fooVoid, std::vector<std::shared_ptr<void>>{iVoid, sVoid} );

    system( "pause" );
}

class-Foo
{
公众：
void foo（int a、const string和b）；
};
模板<类对象，类函数，类arg0，类arg1>
类MemberFunctionWrapper
{
常量函数m_成员函数；
公众：
MemberFunctionWrapper（_函数memFn）
：m_memberfunction（memFn）
{ }
无效呼叫（标准：：共享ptr&obj、，
const std:：vector和args）
{
m_memberfunction（*static_cast<_obj*>（obj.get（）），
*静态强制转换<\u arg0*>（args.at（0.get（）），
*静态强制转换<\u arg1*>（args.at（1.get（））；
}
};
int main（）
{
标准：：共享ptr i（新int（88））；
std:：shared_ptr s（新字符串（“hello”）；
std：：共享_ptr foo（新foo）；
std:：shared_ptr iVoid=std:：static_pointer_cast（i）；
std:：shared\u ptr sVoid=std:：static\u pointer\u cast（s）；
std:：shared\u ptr foovid=std:：static\u pointer\u cast（foo）；
MemberFunctionWrapper
<
福，
decltype（std:：mem_fn（&Foo:：Foo）），
int，
一串
>包装器（&Foo:：Foo）；
call（fooVoid，std:：vector{iVoid，sVoid}）；
系统（“暂停”）；
}

以下内容可能会有所帮助：

模板类MemberFunctionWrapper；
模板
类MemberFunctionWrapper
{
typedef-Ret（对象：：*成员函数）（参数…）；
常量成员函数m_成员函数；
模板
无效呼叫（标准：：共享ptr&obj、，
常量标准：：向量和参数，
索引（U序列）
{
（静态_cast（obj.get（））->*m_成员函数）
（*static_cast（args.at（Is.get（））…）；
}
公众：
MemberFunctionWrapper（MemberFunction memFn）：m_MemberFunction（memFn）
{}
无效呼叫（标准：：共享ptr&obj、，
const std:：vector和args）
{
断言（args.size（）==sizeof…（args））；
调用（obj，args，make_index_sequence（））；
}
};

template<typename F> class MemberFunctionWrapper;

template<class Obj, class Ret, typename ... Args>
class MemberFunctionWrapper<Ret (Obj::*)(Args...)>
{
    typedef Ret (Obj::*MemberFunction)(Args...);
    const MemberFunction m_memberfunction;

    template <std::size_t ... Is>
    void call(std::shared_ptr<void>& obj,
              const std::vector<std::shared_ptr<void>>& args,
              index_sequence<Is...>)
      {
          (static_cast<Obj*>(obj.get())->*m_memberfunction)
              (*static_cast<typename std::remove_reference<Args>::type*>(args.at(Is).get())...);
      }
public:
    MemberFunctionWrapper(MemberFunction memFn) : m_memberfunction(memFn)
    {}

    void call(std::shared_ptr<void>& obj,
              const std::vector<std::shared_ptr<void>>& args )
    {
        assert(args.size() == sizeof...(Args));
        call(obj, args, make_index_sequence<sizeof...(Args)>());
    }

};