Pass a template template argument without specifying the concrete type

Question

I would like to implement a wrapper around a function call that would do something like this:

template <template<class> class F>
void Wrapper(int n, F&& f)
{
    switch (n)
    {
        case 1:
            f<std::int8_t>();
            break;
        case 2:
            f<std::int16_t>();
            break;
        default:
            break;
    }
}

template <class T>
void func()
{
    // ... body of func()
}

So that I would be able to make the following call in the code:

Wrapper(1, func);

But the abovementioned code doesn't compile because F&& f construct is invalid - I need to specify the concrete type of the argument. But if I make the function signature the following:

template <template<class> class F, class T>
void Wrapper(int n, F<T>&& f)

then I must make the call with the concrete type of f:

Wrapper(1, func<std::int8_t>);

and I won't be able to make a switch in Wrapper.

How can I implement the behaviour I need?

Answer 1

If you know func at compile time (that is, if it is not some function pointer), you can use the following solution:

template <template <class> typename F>
void Wrapper(int n) {
  switch (n) {
    case 1: F<std::int8_t>{}(); break;
    case 2: F<std::int16_t>{}(); break;
    default: break;
  }
}

template <typename T>
void func() { std::cout << sizeof(T) << std::endl; }

template <typename T>
struct Func { void operator()() { func<T>(); } };

int main() {
  Wrapper<Func>(1);
  Wrapper<Func>(2);
}