![\"automatic\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/11\/automatic.jpg\")
<\/p>\nThis post is about template interfaces due to the C++ core guidelines: “…a critical concept”, because a template interface is “a contract between a user and an implementer – and should be carefully designed.”.<\/p>\n
<\/p>\n
<\/p>\n
Here are the rules for today:<\/p>\n
using<\/code> over typedef<\/code> for defining aliases<\/a><\/li>\n- T.44: Use function templates to deduce class template argument types (where feasible)<\/a><\/li>\n<\/ul>\n
Let me start with the first rule T.41:<\/p>\n
T.41: Require only essential properties in a template\u2019s concepts<\/a><\/h2>\nWhat does it mean to specify only the essential properties? The guidelines provide an example of a sort algorithm that has debug support.<\/p>\n
\n\ntemplate<\/span><<\/span>Sortable S><\/span>\r\n requires Streamable<<\/span>S><\/span>\r\nvoid<\/span> sort(S&<\/span> s) \/\/ sort sequence s<\/span>\r\n{\r\n if<\/span> (debug) cerr <<<\/span> \"enter sort( \"<\/span> <<<\/span> s <<<\/span> \")<\/span>\\n<\/span>\"<\/span>;\r\n \/\/ ...<\/span>\r\n if<\/span> (debug) cerr <<<\/span> \"exit sort( \"<\/span> <<<\/span> s <<<\/span> \")<\/span>\\n<\/span>\"<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n<\/div>\nOne question remains: What is the issue if you specify non-essential properties? This means that your concepts are firmly bound to the implementation. The result may be that a slight change in the implementation changes your concepts. In the end, your interface becomes quite unstable. <\/p>\n<\/p>\n
T.42: Use template aliases to simplify notation and hide implementation details<\/a><\/h2>\nSince C++11, we have template aliases. A template alias is a name that refers to a family of types. Using them makes your code more readable and helps you to get rid of type traits. My previous post C++ Core Guidelines: Definition of Concepts, the Second<\/a>, provides more information to type traits.<\/p>\nLet’s see what the guidelines mean by readability. The first example uses type traits:<\/p>\n
\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> user(T&<\/span> c)\r\n{\r\n \/\/ ...<\/span>\r\n typename<\/span> container_traits<<\/span>T>::<\/span>value_type x; \/\/ bad, verbose<\/span>\r\n \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\n<\/div>\nHere is the corresponding case with template aliases.<\/p>\n
\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nusing<\/span> Value_type =<\/span> typename<\/span> container_traits<<\/span>T>::<\/span>value_type;\r\n\r\nvoid<\/span> user2<\/span>(T&<\/span> c)\r\n{\r\n \/\/ ...<\/span>\r\n Value_type<<\/span>T><\/span> x;\r\n \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\n<\/div>\nReadability is also the argument that holds for the next rule<\/p>\n
T.43: Prefer using<\/code> over typedef<\/code> for defining aliases<\/a><\/h2>\nThere are two arguments from the readability perspective to prefer using <\/span>over typedef<\/span>. First, using <\/span>comes when used. Second, using <\/span>it feels quite similar to auto<\/span>. Additionally, using<\/span> can easily be used for template aliases.<\/p>\n\n\ntypedef<\/span> int<\/span> (*<\/span>PFI)(int<\/span>); \/\/ OK, but convoluted<\/span>\r\n\r\nusing<\/span> PFI2 =<\/span> int<\/span> (*<\/span>)(int<\/span>); \/\/ OK, preferred<\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\ntypedef<\/span> int<\/span> (*<\/span>PFT)(T); \/\/ error (1) <\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nusing<\/span> PFT2 =<\/span> int<\/span> (*<\/span>)(T); \/\/ OK<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\nThe first two lines define a pointer to a function (PFI <\/span>and PFI2<\/span>) that takes an int <\/span>and returns an int<\/span>. In the first case, typedef <\/span>is used, and in the second line using<\/span>. The last two lines define a function template (PFT2<\/span>) which takes a type parameter T<\/span> and returns an int<\/span>. Line (1) is not valid.<\/p>\nT.44: Use function templates to deduce class template argument types (where feasible)<\/a><\/h2>\nThe primary reason that we have too many make_<\/span> functions, such as std::make_tuple<\/span> or std::make_unique<\/span> is that a function template can deduce its template arguments from its function arguments. During this process, the compiler applies a few simple conversions, such as removing the outermost const\/volatile<\/span> qualifier and decaying C-arrays and functions to a pointer to the first element of the C-array or a pointer to the function.<\/p>\nThis automatic template argument deduction makes our life as a programmer much more straightforward.<\/p>\n
Instead of typing<\/p>\n
\nstd::<\/span>tuple<<\/span>int<\/span>, double<\/span>, std::<\/span>string><\/span> myTuple =<\/span> {2011<\/span>, 20.11<\/span>, \"C++11\"<\/span>};\r\n<\/pre>\n<\/div>\n <\/p>\n
you use the factory function std::make_tuple<\/span>.<\/p>\n\nauto<\/span> myTuple =<\/span> std::<\/span>make_tuple(2011<\/span>, 20.11<\/span>, \"C++11\"<\/span>);\r\n<\/pre>\n<\/div>\n <\/p>\n
Sadly, automatic template type deduction is in C++ only available for function templates. Why? Constructors of class templates are a particular static function. Right! With C++17, the compiler can deduce its template arguments from its constructor arguments. Here is the way to define myTuple<\/span> in C++17.<\/p>\n\nstd::<\/span>tuple myTuple =<\/span> {2017<\/span>, 20.17<\/span>, \"C++17\"<\/span>};\r\n<\/pre>\n<\/div>\n <\/p>\n
A noticeable effect of this C++17 feature is that most of the make_<\/span> functions become obsolete with C++17.<\/p>\nTo know the details about class template argument deduction, including the argument deduction guide, read the post Modern C++ Features – Class Template Argument Deduction<\/a> from Arne Mertz.<\/p>\nTeachability of C++<\/h3>\n
I have to admit; I like this C++17 feature. As a C++ trainer, my job is it to explain this difficult stuff. The more symmetric C++ becomes, the easier for me to speak about general ideas. Now I can say: “A template can automatically deduce its template arguments from its function arguments.”. In the past, I had to say this works only for function templates.<\/p>\n
Here is a simple example:<\/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> std::<\/span>endl;\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> std::<\/span>endl;\r\n }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\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> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The usage of the function template showMe<\/span> or the class template ShowMe<\/span> feels the same. From the user’s perspective, you don’t know you use a template.<\/p>\nWith a current GCC 8.2, the program compiles and runs.<\/p>\n
![\"templateArgumentDeduction\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/11\/templateArgumentDeduction.png\")
<\/p>\n
To be more specific, template argument deduction should work since GCC 7, Clang 5, and MSVC 19.14. cppreference.com <\/a>gives you the details of the compiler support.<\/p>\nWhat’s next?<\/h2>\n