Question

Let’s say you want to write a function which gets passed an opaque handle to a function of unknown type (say, the name of a struct containing a function with an agreed-upon name), and forwards arguments to that function.

In the non-variadic case, considering single-parameter functions for simplicity, there’s two ways to do this: you can let the forwarding function take an argument of arbitrary type, and attempt to call the forwardee function with it, and the compiler will complain during template expansion if it turns out to be incompatible; or you can use decltype and assorted other mechanisms to figure out what type of parameter the forwardee function expects, and explicitly require an argument of that type. I don’t know if there’s any accepted terminology for these, so I’m going to call them “pass through” and “up front”.

The pass through method generalizes straightforwardly to functions with an arbitrary number of parameters, but the up front method doesn’t.

#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;
}

The problem is that parameter packs aren’t allowed to be free-standing, only as template arguments, and if you wrap them in an enclosing template, there’s no way to unwrap-and-unpack them in place, only by pattern matching.

“Up front” has some advantages like better self-documentation, and better support for type inference (up_front<T> can itself be decltyped). Is there any way to make it work in the variadic case? (You could of course use std::tuple, but that’s rather unsatisfying.)

Answer 1

There’s nothing like writing down the question to make you realize the answer.

Here’s one way:

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...);
    }
};

I don’t think there’s a way to make a top-level function out of this (you run into the original problem again), but that’s possibly not too bad.

Would still be happy to see other solutions.