Inconsistency in function type decay between variadic/non-variadic templates?

Question

Given a non-variadic function template:

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

And some plain functions:

void f1(int);
void f2(char);

This works:

f(f1);

The type of t becomes void (*)(int).

However, the variadic counterpart:

template<class... T>
void f(void(...t)(T));

// call
f(f1, f2);

does not work. The compilers (gcc & clang) complain about mismatched types void(T) and void (*)(int). See DEMO.

Note that if * is added explicitly, it works as it should:

template<class... T>
void f(void(*...t)(T));

So, why the non-variadic one can decay the function type while the variadic one cannot?

Answer 1

AFAICS, the code is fine (also supported by the fact that both VC++ and ICC compile it). After all, template argument deduction seems to work with function types just as it does with function pointer or reference types; [temp.deduct.type]/18:

A template-argument can be deduced from a function […] type.

[temp.deduct.call]/1:

For a function parameter pack that occurs at the end of the parameter-declaration-list, deduction is performed for each remaining argument of the call, taking the type P of the declarator-id of the function parameter pack as the corresponding function template parameter type. Each deduction deduces template arguments for subsequent positions in the template parameter packs expanded by the function parameter pack.

In particular the latter paragraph confirms that there is some inconcistency, since the (unsuccessful) deduction of the pack T in the second case reduces to the (successful) deduction in case 1.

My guess is that Clang and GCC decay the parameter types for function templates right at declaration time, but refuse to do so when the parameter is a pack expansion (and then fail to deduce). Clang's error message when we alter the sample call to f(f1) is

note: candidate template ignored: could not match 'void (T)' against 'void (*)(int)'

So the argument is in fact decayed before deduction.

Answer 2

Because your syntax is not quite right.

template<class... T>
void f(void(t)(T...));

void f1(int);

void foo()
{
    f(f1);
}

Tested with gcc 6.1.1. Compiles without errors.

In the non-variadic version, you are using the template parameter as the parameter to the arguments to the passed function parameter.

Therefore, for the variadic version, that's where the parameter pack gets expanded.

Answer 3

Does this explains?

template<class... T>
void f(void(*...t)(T)) {
  std::cout << "Ptr to functions" << std::endl;
}

template<class... T>
void g(void(&...t)(T)) {
  std::cout << "Ref to functions" << std::endl;
}

template <class... T>
void h(void(...t)(T)) {
  std::cout << "Mmmm... potential of confusion" << std::endl;
}

void s1(int) {

}

void s2(long) {

}


#include <type_traits>
int main() {
  // this compiles Ok. The compiler knows
  //    pointer to functions will be passed
  //    and can infer their correspondent T
  f(s1,s2);

  // this compiles Ok. The compiler knows that
  //   reference to functions will be passed
  //   and can infer their correspondent T
  g(s1,s2);

     h(s1,s2);
  // ^^^^^^^^^ this will cause a compilation error telling:
  //   template argument deduction/substitution failed:
  //   mismatched types ‘void(T)’ and ‘void (*)(int)’
  // The compiler can't decide how the function-type parameters are passed
  //  by ptr, by ref, one by ref other by ptr? As such
  //  cannot deduce their correspondent T in the argpack 


  // however, this will compile OK!!!
  // The s1/s2 correspondent T-es in argpack are clearly specified, 
  // not a problem.
  h<int,long>(s1,s2);
  return 0;
}