{"id":6164,"date":"2021-06-17T06:28:24","date_gmt":"2021-06-17T06:28:24","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/template-argument-deduction-of-class-templates\/"},"modified":"2021-06-17T06:28:24","modified_gmt":"2021-06-17T06:28:24","slug":"template-argument-deduction-of-class-templates","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/template-argument-deduction-of-class-templates\/","title":{"rendered":"Template Argument Deduction of Class Templates"},"content":{"rendered":"

In my last post, Template Arguments<\/a>, I wrote about function template type deduction (C++98) and auto type deduction (C++11). Today I wear more modern hats. I start with automatic type deduction of non-type template parameters and class templates (C++17) and finish with automatic type deduction of concepts (C++20).<\/p>\n

<\/p>\n

 \"\"<\/p>\n

Following the chronological order, let me start with two C++17 features: type deduction of non-type template parameters and type deduction of class templates in C++17.<\/p>\n

Automatic type deduction of non-type template parameters<\/h2>\n

First of all. What are non-type template parameters? These are nullptr<\/code>, integral values such as bool<\/code>, and int<\/code>, lvalue references, pointer, enumerations, and with C++20 floating-point values. Most of the time, integral types are used, and so do I.<\/p>\n

After this theory, let’s start with an example.<\/p>\n

<\/p>\n

\n
template<\/span> <<\/span>auto<\/span> N>          \/\/ (1)<\/span><\/span>\r\nclass<\/span> MyClass<\/span>{\r\n    ....\r\n};\r\n\r\ntemplate<\/span> <<\/span>int<\/span> N><\/span>          \/\/ (2)<\/span>\r\nclass<\/span> MyClass<\/span><<\/span>N><\/span> {\r\n    ....\r\n};\r\n\r\n\r\nMyClass<<\/span>'x'<\/span>><\/span> myClass1;    \/\/ (3)<\/span>\r\nMyClass<<\/span>2017<\/span>><\/span>  myClass2;  \/\/ (4)<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
By using auto<\/span> in (1) in the template signature,  N<\/span> is a non-type template parameter. The compiler will automatically deduce it. You can also partially specialize for int <\/span>(2). The template instantiation (3) will use the primary template (1), and the following template instantiation the partial specialization for int <\/span>(4).
<\/span><\/p>\n
The usual type modifiers can be used to constrain the type of the non-type template parameters.<\/p>\n
<\/p>\n
\n
template<\/span> <<\/span>const<\/span> auto<\/span>*<\/span> p><\/span> \r\nclass<\/span> S;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In this declaration of a class template S<\/code>, p<\/span> must be a pointer to const.<\/span><\/p>\n
The automatic type deduction for non-type templates can also be applied to variadic templates.<\/p>\n
<\/p>\n
\n
template<\/span> <<\/span>auto<\/span>... ns><\/span> \r\nclass<\/span> VariadicTemplate<\/span>{ .... }; \r\n\r\ntemplate<\/span> <<\/span>auto<\/span> n1, decltype(n1)... ns><\/span>\r\nclass<\/span> TypedVariadicTemplate<\/span>{ .... };\r\n<\/pre>\n<\/div>\n
 <\/p>\n
VariadicTemplate<\/span> can deduce an arbitrary number of non-type template parameters. TypeVariadicTemplate<\/span> will only deduce the first template parameter. The remaining templated parameters will be of the same type as the first type: decltype(n1)<\/code>.<\/p>\n
Automatic type deduction from class templates makes the usage of class templates quite comfortable.<\/p>\n<\/p>\n
Automatic Type Deduction of Class Templates<\/h2>\n
A function template can deduce its type parameters from its function arguments. But that was not possible for particular functions: constructors of class templates. With C++17, this statement is simply wrong. A constructor can deduce its type parameters from its constructor arguments. Here is the first example.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ templateArgumentDeduction.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> showMe(const<\/span> T&<\/span> t) {\r\n    std::<\/span>cout <<<\/span> t <<<\/span> '\\n'<\/span>;\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nstruct<\/span> ShowMe{\r\n    ShowMe(const<\/span> T&<\/span> t) {\r\n        std::<\/span>cout <<<\/span> t <<<\/span> '\\n'<\/span>;\r\n    }\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n  \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    showMe(5.5<\/span>);          \/\/ not showMe<double>(5.5);<\/span>\r\n    showMe(5<\/span>);            \/\/ not showMe<int>(5);<\/span>\r\n    \r\n    ShowMe(5.5<\/span>);          \/\/ not ShowMe<double>(5.5);<\/span>\r\n    ShowMe(5<\/span>);            \/\/ not ShowMe<int>(5);<\/span>\r\n  \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Let me say a few words about the main<\/code> function. The instantiation of the function template showMe<\/code> <\/code>has been valid since the first C++ standard C++98, but the instantiation of the class template ShowMe<\/code> since C++17. From the user’s perspective, using functions templates or class templates feels just like an ordinary function or class.<\/p>\n
\"templateArgumentDeduction\"<\/p>\n
Maybe, you are not convinced. Here are more examples of class template argument deduction.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ classTemplateArgumentDeduction.cpp<\/span>\r\n\r\n#include <array><\/span>\r\n#include <vector><\/span>\r\n#include <mutex><\/span>\r\n#include <memory><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n  \r\n    std::<\/span>array myArr{1<\/span>, 2<\/span>, 3<\/span>};          \/\/ deduces std::array<int, 3> <\/span>\r\n    std::<\/span>vector myVec{1.5<\/span>, 2.5<\/span>};        \/\/ deduces std::vector<double><\/span>\r\n \r\n    std::<\/span>mutex mut;\r\n    std::<\/span>lock_guard myLock(mut);       \/\/ deduces std::lock_guard<mutex>(mut);<\/span>\r\n  \r\n    std::<\/span>pair myPair(5<\/span>, 5.5<\/span>);          \/\/ deduces std::pair<int, double><\/span>\r\n    std::<\/span>tuple myTup(5<\/span>, myArr, myVec); \/\/ deduces std::tuple<int, <\/span>\r\n                                       \/\/ std::array<int, 3>, std::vector<double>><\/span>\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The comments show the C++17 compiler deduced types. Thanks to C++ Insights<\/a>, you can visualize this process of template argument deduction.<\/p>\n
The last two examples to std::pair and std::tuple are pretty interesting. Before C++17, we used factory functions such as std::make_pair or std::make_tuple to create a std::pair or a std::tuple without specifying the type parameters. In contrast to class templates, the compiler could deduce the type parameter from the function arguments. Here is a simplified version of std::pair<\/code>.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ makePair.cpp
<\/span>\r\n#include <utility><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T1, typename<\/span> T2><\/span>\r\nstd::<\/span>pair<<\/span>T1, T2><\/span> make_pair2(T1 t1, T2 t2) { \r\n    return<\/span> std::<\/span>pair<<\/span>T1, T2><\/span>(t1, t2); \r\n}\r\n\r\nint<\/span> main() {\r\n\t\r\n   auto<\/span> arg{5.5<\/span>};\r\n   auto<\/span> pair1 =<\/span> std::<\/span>make_pair(5<\/span>, arg);\r\n   auto<\/span> pair2 =<\/span> make_pair2(5<\/span>, arg);\r\n   auto<\/span> pair3 =<\/span> std::<\/span>pair(5<\/span>, arg);\r\n   \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The compiler deduces the same type for pair1<\/code> and pair2<\/code>. With C++17, we don’t need this factory function anymore and can directly invoke the constructor of std::pair<\/code> to get pair3<\/code>.<\/p>\n
\"makePair\"<\/p>\n
You can study the program on C++ Insights<\/a>.<\/p>\n
You may wonder why my function template make_pair2<\/code> took its arguments by value. std::make_pair<\/code> decays its arguments, and so does my function template make_pair2<\/code>. I wrote about the decay of function arguments in my last post Template Arguments<\/a>.<\/p>\n
Before I write a few words about the automatic type deduction with concepts, I want to emphasize is explicit. Automatic type deduction is more than convenient. It’s a security feature. You cannot make an error when you don’t specify the type.<\/strong><\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ automaticTypeDeduction.cpp<\/span>\r\n\r\n#include <string><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> func(T) {};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nstruct<\/span> Class{\r\n  Class(T){}\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n  \r\n    int<\/span> a1 =<\/span> 5.5<\/span>;              \/\/ static_cast<int>(5.5)<\/span>\r\n    auto<\/span> a2 =<\/span> 5.5<\/span>;\r\n  \r\n    func<<\/span>float<\/span>><\/span>(5.5<\/span>);          \/\/ static_cast<float>(5.5)<\/span>\r\n    func(5.5<\/span>);\r\n  \r\n    Class<<\/span>std::<\/span>string><\/span> class1(\"class\"<\/span>); \/\/ calls essentially std::string(\"class\")<\/span>\r\n    Class class2(\"class\"<\/span>);\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
All errors are only because I explicitly specified the type:<\/p>\n