将重载函数指针作为重载模板函数的参数传递

Question

我试图让编译器推断出正确的函数模板。 给定以下代码，可以推导出正确的模板化函数...

class TestBase{};

template <typename c, typename RT, typename T0>
inline void CallF( RT( c::*M )(T0), TestBase* pObject, std::vector<OVariant> args )
{
    //safely convert variant (implementations external to class)
    T0 t0 = args[0].GetSafe<T0>();

    ((static_cast<c*>(pObject))->*M)(t0);
}

template <typename c, typename RT, typename T0, typename T1>
inline void CallF( RT( c::*M )(T0, T1), TestBase* pObject, std::vector<OVariant> args )
{
    //safely convert variant (implementations external to class)
    T0 t0 = args[0].GetSafe<T0>();
    T1 t1 = args[1].GetSafe<T1>();

    ((static_cast<c*>(pObject))->*M)(t0, t1);
}

class Test : public TestBase
{
public:

    void F( s32 one )
    {
        std::cout << "one";
    }

    struct Wrapped_F
    {
        //OVariant is my typical variant class
        static void Call( TestBase* pObject, std::vector<OVariant> args )
        {
            ::CallF<Test>( &Test::F, pObject, args );
        }
    };
};

int main(int argc, char *argv[])
{
    Test t;
    OVariant i( 13 );
    std::vector<OVariant> args;
    args.push_back( i );

    t.Wrapped_F::Call( &t, args );
}

t.Wrapped_F :: Call（＆t，args）调用正确的F函数。 但是，如果我将重载的F函数添加到Test，则会调用它（具有2个args的过载）（而不是具有1个arg的正确F）

void F( s32 one, s32 two )
{
    std::cout << "two";
}

我很确定这是由于编译器没有足够的信息可推断的事实。 如何帮助编译器推断要调用的重载模板函数？

类似于以下伪代码...（？表示未知类型的arg）

static void Call( TestBase* pObject, std::vector<OVariant> args )
{
    //Note: I won't know anything about the arguments to function F; I do know the size of the vector
    switch ( args.size() )
    {
    case 1:::CallF<Test,void,?>( &Test::F, pObject, args );
    case 2:::CallF<Test,void,?,?>( &Test::F, pObject, args );
    }
}

有没有办法做到这一点？

Answer 1

编译器无法知道变量类中存储了什么。 那么? 只能从函数类型（从其参数）推导得出。 因此，您将需要一些代码来检查args.size()与函数参数的数量是否匹配。 尝试执行以下操作：

• 创建std::tuple<Args...> ，其中Args...从函数类型求值
• 检查args.size()是否与std::tuple<Args...>的元素数相同
• 将您的args向量转换为元组。
• 使用std::apply （或重新发明自己的函数）以元组中的参数调用函数