If you wanted to create templates with non-type template parameters, you had to specify both the type and the value. In C++17, this is no longer the case, as template <auto><\/tt> helps simplify these scenarios.<\/p>\n
Let’s take as an example the declaration of a constant template.<\/p>\n
template <typename T, T value> \r\nconstexpr T numeric_constant = value;\r\n\r\nconstexpr auto const the_answer = numeric_constant<int, 42>;<\/pre>\nIn C++17, this can be simplified as follows:<\/p>\n
template <auto value> \r\nconstexpr auto numeric_constant = value;\r\n\r\nconstexpr auto const the_answer = numeric_constant<42>;<\/pre>\nYou no longer need to specify the type for non-type template parameters, it is automatically deduced by the compiler. Here is another example:<\/p>\n
template <auto value> \r\nvoid foo() { \/*... *\/ }\r\n\r\nfoo<42>(); \/\/ deduces int\r\nfoo<false>(); \/\/ deduces bool\r\n<\/pre>\nLet’s look at an example where template <auto><\/tt> can simplify the code. The standard defines a type called std::integral_constant<\/tt> that wraps a static constant of a specified type and is the base class for the C++ type traits. std::true_type<\/tt> and std::false_type<\/tt> are two of those. These could be implemented as follows:<\/p>\n
\r\ntemplate<class T, T val>\r\nstruct integral_constant\r\n{\r\n static constexpr T value = val;\r\n\r\n using value_type = T;\r\n using type = integral_constant;\r\n\r\n constexpr operator value_type() const noexcept { return value; }\r\n\r\n [[nodiscard]] constexpr value_type operator()() const noexcept { return value; }\r\n};\r\n\r\ntemplate<bool val>\r\nusing bool_constant = integral_constant<bool, val>;\r\n\r\nusing true_type = bool_constant<true>;\r\nusing false_type = bool_constant<false>;<\/pre>\nWith template <auto><\/tt> this code can be written as following:<\/p>\n
\r\ntemplate<auto val>\r\nstruct integral_constant\r\n{\r\n static constexpr auto value = val;\r\n\r\n using value_type = decltype(val);\r\n using type = integral_constant;\r\n\r\n constexpr operator value_type() const noexcept { return value; }\r\n\r\n [[nodiscard]] constexpr value_type operator()() const noexcept { return value; }\r\n};\r\n\r\nusing true_type = integral_constant<true>;\r\nusing false_type = integral_constant<false>;<\/pre>\nNote<\/strong>: Although this works fine with Clang and GCC, VC++ 15.7 complains about the use of decltype(val)<\/tt>.<\/p>\n
Note<\/strong>: It may be more cumbersome to deduce some types. For instance, if you need a short<\/tt> type, there is no way to specify a short<\/tt> literal. You must indicate that with a cast. In order words, if you want a short<\/tt> 42 integral constant, you need to declare it like this:<\/p>\n
using short_42 = integral_constant<(short)42>;<\/pre>\nThis feature is also useful with variadic templates for creating compile-time lists of henerogenous values. Here is an example:<\/p>\n
template <auto ... vs>\r\nstruct heterogenous_list {};\r\n\r\nusing ultimate_list = heterogenous_list<42, \"the ultimate answer\", true>;<\/pre>\n