{"id":6173,"date":"2021-07-09T07:07:17","date_gmt":"2021-07-09T07:07:17","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/full-specialization-of-function-templates\/"},"modified":"2021-07-09T07:07:17","modified_gmt":"2021-07-09T07:07:17","slug":"full-specialization-of-function-templates","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/full-specialization-of-function-templates\/","title":{"rendered":"Full Specialization of Function Templates"},"content":{"rendered":"

As you may know from my previous post, Template Specialization<\/a>, a function template can only be full but not partially specialized. To make my long story short: Don’t specialize function templates<\/a>. Just use function overloading.<\/p>\n

<\/p>\n

 \"TemplateSpecialization\"<\/p>\n

You may wonder why I write about a feature of C++ you should not use. The reason is quite simple. When you see the surprising behavior of fully specialized function templates, you will hopefully use a non-generic function instead.<\/p>\n

Don’t Specialize Function Templates<\/h2>\n

Maybe the title reminds you? Right. This title is from the C++ Core Guidelines: T.144: Don\u2019t specialize function templates<\/a><\/p>\n

The reason for the rules is relatively short: function template specialization doesn’t participate in overloading. Let’s see what that means. My program is based on the program snippet from Dimov\/Abrahams<\/a>.<\/p>\n

\n
\/\/ dimovAbrahams.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\n\/\/ getTypeName<\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>            \/\/ (1) primary template<\/span>\r\nstd::<\/span>string getTypeName(T){\r\n    return<\/span> \"unknown\"<\/span>;\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>            \/\/ (2) primary template that overloads (1)<\/span>\r\nstd::<\/span>string getTypeName(T*<\/span>){\r\n    return<\/span> \"pointer\"<\/span>;\r\n}\r\n\r\ntemplate<\/span><><\/span>                      \/\/ (3) explicit specialization of (2)<\/span>\r\nstd::<\/span>string getTypeName(int<\/span>*<\/span>){\r\n    return<\/span> \"int pointer\"<\/span>;\r\n}\r\n\r\n\/\/ getTypeName2<\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>            \/\/ (4) primary template<\/span>\r\nstd::<\/span>string getTypeName2(T){\r\n    return<\/span> \"unknown\"<\/span>;\r\n}\r\n\r\ntemplate<\/span><><\/span>                      \/\/ (5) explicit specialization of (4)<\/span>\r\nstd::<\/span>string getTypeName2(int<\/span>*<\/span>){\r\n    return<\/span> \"int pointer\"<\/span>;\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>            \/\/ (6) primary template that overloads (4)<\/span>\r\nstd::<\/span>string getTypeName2(T*<\/span>){\r\n    return<\/span> \"pointer\"<\/span>;\r\n}\r\n\r\nint<\/span> main(){\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    int<\/span>* <\/span>p;\r\n    \r\n    std::<\/span>cout <<<\/span> \"getTypeName(p): \"<\/span> <<<\/span> getTypeName(p) <<<\/span>  '\\n';  \r\n    std::<\/span>cout <<<\/span> \"getTypeName2(p): \"<\/span> <<<\/span> getTypeName2(p) <<<\/span>  '\\n';\r\n    \r\n    std::<\/span>cout <<<\/span>  '\\n';\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Admittedly, the code looks quite boring but bear with me. I defined inline (1) the primary template getTypeName.<\/span> (2) is an overload for pointers, and (3) a full specialization for an int<\/code> pointer. In the case of getTypeName2,<\/span> I made a small variation. I put the explicit specialisation<\/code> (5) before the overload for pointers (6).<\/p>\n
This reordering has surprising consequences.<\/p>\n
\"dimovAbrahams\"<\/p>\n
In the first case, the full specialization for the int<\/span> pointer is called, and in the second case, the overload of pointers. What?  This non-intuitive behavior is because overload resolution ignores function template specialization. Overload resolution operates on primary templates and functions. In both cases, overload resolutions found both primary templates. In the first case (getTypeName<\/span>), the pointer variant is the better fit and, therefore, the explicit specialization for the int<\/span> pointer was chosen. The pointer variant was chosen in the second variant (getTypeName2), but the full specialization belongs to the primary template (line 4). Consequently, it was ignored.<\/p>\n
I know this wasn’t very easy. Just keep the rule in mind: Don’t specialize function templates; use non-generic functions instead.<\/strong><\/p>\n
Do you want to have proof of my statement? Here it is: Making out of the explicit specialization in (3) and (5) non-generic functions solves the issue. I have to comment out the template declaration template<><\/code>. For simplicity reasons, I removed the other comments.<\/p>\n
 <\/p>\n
\n
\/\/ dimovAbrahams.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\n\/\/ getTypeName<\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>           \r\nstd::<\/span>string getTypeName(T){\r\n    return<\/span> \"unknown\"<\/span>;\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>            \r\nstd::<\/span>string getTypeName(T*<\/span>){\r\n    return<\/span> \"pointer\"<\/span>;\r\n}\r\n
\/\/ template<\/span><><\/span>                      \/\/ (3)<\/span>\r\nstd::<\/span>string getTypeName(int<\/span>*<\/span>){\r\n    return<\/span> \"int pointer\"<\/span>;\r\n}\r\n\r\n\/\/ getTypeName2<\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>           \r\nstd::<\/span>string getTypeName2(T){\r\n    return<\/span> \"unknown\"<\/span>;\r\n}\r\n
\/\/ template<\/span><><\/span>                      \/\/ (5) <\/span>\r\nstd::<\/span>string getTypeName2(int<\/span>*<\/span>){\r\n    return<\/span> \"int pointer\"<\/span>;\r\n}\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>           \r\nstd::<\/span>string getTypeName2(T*<\/span>){\r\n    return<\/span> \"pointer\"<\/span>;\r\n}\r\n\r\nint<\/span> main(){\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    int<\/span>* <\/span>p;\r\n    \r\n    std::<\/span>cout <<<\/span> \"getTypeName(p): \"<\/span> <<<\/span> getTypeName(p) <<<\/span>  '\\n';  \r\n    std::<\/span>cout <<<\/span> \"getTypeName2(p): \"<\/span> <<<\/span> getTypeName2(p) <<<\/span>  '\\n';\r\n    \r\n    std::<\/span>cout <<<\/span>  '\\n';\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Now, function overloading works as expected, and the non-generic function takes an int<\/code> pointer is used.<\/p>\n
\"dimovAbrahams2\"<\/p>\n
I already wrote about Template Arguments. But I forgot one crucial fact. You can provide default template arguments for function templates and class templates.<\/p>\n<\/p>\n
Default Template Arguments<\/h2>\n
What is common to the Standard Template Library class templates (STL)? Yes! Many of the template arguments have defaults.<\/p>\n
Here are a few examples.<\/p>\n
<\/p>\n
\n
template<\/span><<\/span>\r\n    typename<\/span> T,\r\n    typename<\/span> Allocator =<\/span> std::<\/span>allocator<<\/span>T><\/span>\r\n><\/span> class<\/span> vector<\/span>;\r\n\r\ntemplate<\/span><<\/span>\r\n    typename<\/span> Key,\r\n    typename<\/span> T,\r\n    typename<\/span> Hash =<\/span> std::<\/span>hash<<\/span>Key><\/span>,\r\n    typename<\/span> KeyEqual =<\/span> std::<\/span>equal_to<<\/span>Key><\/span>,\r\n    typename<\/span> Allocator =<\/span> std::<\/span>allocator<<\/span> std::<\/span>pair<<\/span>const<\/span> Key, T>><\/span>\r\n><\/span> class<\/span> unordered_map<\/span>;\r\n\r\ntemplate<\/span><<\/span>\r\n    typename<\/span> T,\r\n    typename<\/span> Allocator =<\/span> std::<\/span>allocator<<\/span>T><\/span>\r\n><\/span> class<\/span> deque<\/span>;\r\n\r\ntemplate<\/span><<\/span>\r\n    typename<\/span> T,\r\n    typename<\/span> Container =<\/span> std::<\/span>deque<<\/span>T><\/span>\r\n><\/span> class<\/span> stack<\/span>;\r\n\r\ntemplate<\/span><<\/span>\r\n    typename<\/span> CharT,\r\n    typename<\/span> Traits =<\/span> std::<\/span>char_traits<<\/span>CharT><\/span>,\r\n    typename<\/span> Allocator =<\/span> std::<\/span>allocator<<\/span>CharT><\/span>\r\n><\/span> class<\/span> basic_string<\/span>;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
This is part of the power of the STL:<\/p>\n