C++11：计算可变参数函数参数类型

Question

假设您要编写一个函数，该函数将不透明句柄传递给未知类型的函数（例如，包含具有商定名称的函数的结构的名称），并将参数转发给该函数。

在非可变参数的情况下，为了简单起见，考虑单参数函数，有两种方法可以做到这一点：您可以让转发函数接受任意类型的参数，并尝试用它调用转发者函数，编译器会抱怨在模板扩展期间如果发现不兼容；或者您可以使用 decltype 和各种其他机制来确定转发者函数期望的参数类型，并明确要求该类型的参数。我不知道这些是否有任何公认的术语，所以我将它们称为“通过”和“预先”。

传递方法可以直接推广到具有任意数量参数的函数，但前面的方法则不然。

#include <iostream>

template<typename T, typename Arg>
void pass_through_1(Arg arg)
{
    T::f(arg);
}

template<typename T> struct arg_of_1;

template<typename Ret, typename Arg>
struct arg_of_1<Ret (Arg)>
{
    typedef Arg type;
};

template<typename T>
void up_front_1(typename arg_of_1<decltype(T::f)>::type arg)
{
    T::f(arg);
}

template<typename T, typename... Args>
void pass_through_var(Args... args)
{
    T::f(args...);
}

template<typename T> struct args_of_var;

template<typename...> struct type_list;

template<typename Ret, typename... Args>
struct args_of_var<Ret (Args...)>
{
    // typedef Args... type; // can't do this
    typedef type_list<Args...> type;
};

// template<typename T>
// void up_front_var(typename args_of_var<decltype(T::f)>::type... args) // can't do this
// {
//     T::f(args...);
// }

struct test  
{ 
    static void f(int x) { std::cout << x*9 << std::endl; }
};

int main(int, char**)
{
    pass_through_1<test>(7);
    up_front_1<test>(8);
    pass_through_var<test>(9);
    // up_front_var<test>(10);
    return 0;
}

问题是参数包不允许独立存在，只能作为模板参数，如果将它们包装在封闭的模板中，则无法将它们解开并解开，只能通过模式匹配。

“Up front”具有一些优点，例如更好的自文档以及对类型推断的更好支持（up_front本身可以被 decltyped）。有什么方法可以让它在可变的情况下工作吗？ （您当然可以使用 std::tuple，但这相当不令人满意。）

Answer 1

没有什么比写下问题更能让你找到答案了。

这是一种方法：

template<typename T, typename Args = typename args_of_var<decltype(T::f)>::type>
struct up_front_var;

template<typename T, typename... Args>
struct up_front_var<T, type_list<Args...>>
{
    static void forward(Args... args)
    {
        T::f(args...);
    }
};

我认为没有办法从中创建一个顶级函数（您再次遇到原始问题），但这可能还不错。

仍然很高兴看到其他解决方案。

Answer 2

也许我没有正确理解这个问题，但你总是可以省略参数类型并让编译器推断它们。

/* declare */
template<typename T, typename... Args>
void up_front_var(Args... args)
{
    T::f(std::forward<Args>(args)...); // need std::forward to correctly handle lvalue/rvalue references
}

/* an example */
class Test {
public:
    static void f(const char* fmt, int a, int b);
};

void Test::f(const char* fmt, int a, int b)
{
    printf(fmt, a, b); 
}


int main()
{
    up_front_var<Test>("testing %u, %u", 1, 2); // no need to specify arguments here
    return 0;
}