Passing template function as argument for normal function

Question

I'm wondering if it's possible to pass a template function (or other) as an argument to a second function (which is not a template). Asking Google about this only seems to give info about the opposite ( Function passed as template argument )

The only relevant page I could find was http://www.beta.microsoft.com/VisualStudio/feedbackdetail/view/947754/compiler-error-on-passing-template-function-as-an-argument-to-a-function-with-ellipsis (not very helpful)

I'm expecting something like:

template<class N>void print(A input){cout << input;}
void execute(int input, template<class N>void func(N)){func(input)}

and then later call

execute(1,print);

So, can this be done or would another template have to be defined for execute() ?

Answer 1

Function templates represent an infinite overload set, so unless you have a target type that is compatible with a specialization, deduction of the function type always fails. For example:

template<class T> void f(T);
template<class T> void h(T);

void g() {
    h(f); // error: couldn't infer template argument 'T'
    h(f<int>); // OK, type is void (*)(int)
    h<void(int)>(f); // OK, compatible specialization
}

From above we can see that the validity of the program demands that we specify the template arguments for the function template, when in general it isn't always intuitive to specify them. You can instead make print a functor with a generic overloaded call operator as an extra level of indirection:

struct print {
     template<typename T>
     void operator()(T&& x) const {
         std::cout << x;
     }
};

Now you can have execute accept any Callable and invoke it with the input:

template<class T, class Op>
void execute(T&& input, Op&& op) {
    std::forward<Op>(op)(std::forward<T>(input));
}

void g() { execute(1, print{}); }

Generic lambdas (C++14) make this a lot more concise:

execute(1, [] (auto&& x) { std::cout << x; });