Why are variadic templates different than non-variadic, for only one argument?

Question

This code compiles just fine:

template <typename T1>
struct Struct {
};

struct ConvertsToStruct {
    operator Struct<int>() const;
};

template <typename T>
void NonVariadicFunc(Struct<T>);

int main() {
      NonVariadicFunc<int>(ConvertsToStruct{});
      return 0;
}

But an attempt to make it a little more generic, by using variadic templates, fails to compile:

template <typename T1>
struct Struct {
};

struct ConvertsToStruct {
    operator Struct<int>() const;
};

template <typename... T>
void VariadicFunc(Struct<T...>);

int main() {
      VariadicFunc<int>(ConvertsToStruct{});
      return 0;
}

What's going wrong? Why isn't my attempt to explicitly specify VariadicFunc's template type succeeding?

Godbolt link => https://godbolt.org/g/kq9d7L

Answer 1

There are 2 reasons to explain why this code can't compile.

The first is, the template parameter of a template function can be partially specified:

template<class U, class V> void foo(V v) {}

int main() {
      foo<double>(12);
}

This code works, because you specify the first template parameter U and let the compiler determine the second parameter. For the same reason, your VariadicFunc<int>(ConvertsToStruct{}); also requires template argument deduction. Here is a similar example, it compiles:

template<class... U> void bar(U... u) {}

int main() {
      bar<int>(12.0, 13.4f);
}

Now we know compiler needs to do deduction for your code, then comes the second part: compiler processes different stages in a fixed order:

cppreference

Template argument deduction takes place after the function template name lookup (which may involve argument-dependent lookup) and before template argument substitution (which may involve SFINAE) and overload resolution.

Implicit conversion takes place at overload resolution, after template argument deduction. Thus in your case, the existence of a user-defined conversion operator has no effect when compiler is doing template argument deduction. Obviously ConvertsToStruct itself cannot match anything, thus deduction failed and the code can't compile.