Parameter pack must be at the end of the parameter list… When and why?

by

It is valid for function templates but only when argument deduction can help the compiler resolve the template parameters, as it stands your function template example is virtually useless because

template<typename T, typename... Args, typename S> void fn() { }
int main() { fn<int, int, int>(); }

test.cpp: In function 'int main()':
test.cpp:2:32: error: no matching function for call to 'fn()'
 int main() { fn<int, int, int>(); }
                                ^
test.cpp:1:57: note: candidate: template<class T, class ... Args, class S> void fn()
 template<typename T, typename... Args, typename S> void fn() { }
                                                         ^
test.cpp:1:57: note:   template argument deduction/substitution failed:
test.cpp:2:32: note:   couldn't deduce template parameter 'S'
 int main() { fn<int, int, int>(); }

the compiler has no way of determining which template parameters belong to the parameter pack, and which to S. In fact as @T.C. points out it should actually be a syntax error because a function template defined in this manner cannot ever be instantiated.

A more useful function template would be something like

template<typename T, typename... Args, typename S> void fn(S s) { }

as now the compiler is able to unambiguously match the function parameter s with the template type S, with the side effect that S will always be deduced – all explicit template parameters after the first will belong to Args.

None of this works for (primary) class templates, parameters aren’t deduced and it’s expressly forbidden:

From draft n4567

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4567.pdf

[temp.param] / 11

[…]If a template-parameter of a primary class template or alias
template is a template parameter pack, it shall be the last
template-parameter.[…]

(if they were deduced it would be ambiguous as in the function template example).

More Related Contents:

  1. Variadic template pack expansion
  2. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  3. Calling a function for each variadic template argument and an array
  4. Is it possible to “store” a template parameter pack without expanding it?
  5. How to reverse the order of arguments of a variadic template function?
  6. What does this variadic template code do?
  7. Expansion with variadic templates [duplicate]
  8. C++ parameter pack, constrained to have instances of a single type?
  9. Variadic templates
  10. What is the easiest way to print a variadic parameter pack using std::ostream?
  11. Variadic function template with pack expansion not in last parameter
  12. How can I expand call to variadic template base classes?
  13. How to make a variadic is_same?
  14. Is there a way to write make_unique() in VS2012?
  15. How to combine std::bind(), variadic templates, and perfect forwarding?
  16. Optimization code for a debug function (c++11 with templates) [closed]
  17. C++11 does not deduce type when std::function or lambda functions are involved
  18. How to convert a lambda to an std::function using templates
  19. When to use std::forward to forward arguments?
  20. check variadic templates parameters for uniqueness
  21. Can someone please explain the “indices trick”?
  22. Variadic deduction guide not taken by g++, taken by clang++ – who is correct?
  23. Default template argument when using std::enable_if as templ. param.: why OK with two template functions that differ only in the enable_if parameter?
  24. Why the initializer of std::function has to be CopyConstructible?
  25. Interfacing C++11 array with Cython
  26. using SFINAE for template class specialisation
  27. std::enable_if : parameter vs template parameter
  28. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  29. Specializing a template on a lambda in C++0x
  30. template parameter packs access Nth type and Nth element

Leave a Comment