![\"animal](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/02\/animal-1821737_1280.jpg\")
<\/p>\nToday, I finish the C++ core guidelines rules to templates with a big surprise for many C++ developers. I write about the specialization of function templates.<\/p>\n
<\/p>\n
<\/p>\n
Let’s start simple. Here is a template specialization from a bird-eyes perspective.<\/p>\n
Templates define the behavior of families of classes and functions. Often it is necessary that special types or non-types may be treated special. To support this use case, you fully specialize in templates. Class templates can even be partially specialized.<\/p>\n
Here is a code snippet to get a general idea.<\/p>\n
template<\/span> <<\/span>typename<\/span> T, int<\/span> Line, int<\/span> Column><\/span> \/\/ (1)<\/span>\r\nclass<\/span> Matrix<\/span>;\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span> \/\/ (2)<\/span>\r\nclass<\/span> Matrix<\/span><<\/span>T, 3<\/span>, 3<\/span>><\/span>{};\r\n\r\ntemplate<\/span> <><\/span> \/\/ (3)<\/span>\r\nclass<\/span> Matrix<\/span><<\/span>int<\/span>, 3<\/span>, 3<\/span>><\/span>{};\r\n<\/pre>\n<\/div>\n <\/p>\n
Line 1 is the primary or general template. This template must be declared at least and has to be declared before the partially or fully specialized templates. Line 2 follows with the partial specialization. Line 3 is the full specialization. <\/p>\n
To better understand partially and fully specialisation, I want to present a visual explanation. Think about an n-dimensional space of template parameters. In the primary template (line 1) you can choose an arbitrary type, and two arbitrary int<\/span>‘s. In the case of the partial specialization in line 2, you can only choose the type. This means the 3-dimensional space is reduced to a line. Fully specialization means that you have one point in a 3-dimensional space. <\/p>\nWhat is happening when you invoke the templates?<\/p>\n
<\/p>\n
\nMatrix<<\/span>int<\/span>, 3<\/span>, 3<\/span>><\/span> m1; \/\/ class Matrix<int, 3, 3><\/span>\r\n\r\nMatrix<<\/span>double<\/span>, 3<\/span>, 3<\/span>><\/span> m2; \/\/ class Matrix<T, 3, 3> <\/span>\r\n\r\nMatrix<<\/span>std::<\/span>string, 4<\/span>, 3<\/span>><\/span> m3; \/\/ class Matrix<T, Line, Column> => ERROR<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
m1<\/span> uses the full specialization, m2<\/span> uses the partial specialization, and m3<\/span> the primary template which causes an error because the definition is missing.<\/p>\nHere are three rules which the compiler uses to get the right specialization:<\/p>\n
\n- The compiler finds only one specialisation. The compiler uses specialisation.<\/li>\n
- The compiler finds more than one specialisation. The compiler uses the most specialized one. If this process ends in more than one specialization, the compiler throws an error.<\/li>\n
- The compiler finds no specialisation. It uses the primary specialisation.<\/li>\n<\/ol>\n
Okay, I have to explain what A is a more specialized template than B means. Here is the informal definition of cppreference.com<\/a>: “A accepts a subset of the types that B accepts<\/em>“.<\/p>\nAfter the first overview, I can dig a little bit deeper into function templates.<\/p>\n<\/p>\n
Specialisation and Overloading of Function Templates<\/h2>\n
Function templates make the job of template specialization easier but also more difficult at the same time.<\/p>\n
\n- Easier, because the function template only supports full specialisation.<\/li>\n
- More difficult because function overloading comes into play.<\/li>\n<\/ul>\n
From the design perspective, you can specialize a function template with template specialization or overloading.<\/p>\n
<\/p>\n
\n\/\/ functionTemplateSpecialisation.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span> \/\/ (1)<\/span>\r\nstd::<\/span>string getTypeName(T){\r\n return<\/span> \"unknown type\"<\/span>;\r\n}\r\n\r\ntemplate<\/span> <><\/span> \/\/ (2)<\/span>\r\nstd::<\/span>string getTypeName<<\/span>int<\/span>><\/span>(int<\/span>){\r\n return<\/span> \"int\"<\/span>;\r\n}\r\n\r\nstd::<\/span>string getTypeName(double<\/span>){ \/\/ (3)<\/span>\r\n return<\/span> \"double\"<\/span>;\r\n}\r\n\r\nint<\/span> main(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"getTypeName(true): \"<\/span> <<<\/span> getTypeName(true<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"getTypeName(4711): \"<\/span> <<<\/span> getTypeName(4711<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"getTypeName(3.14): \"<\/span> <<<\/span> getTypeName(3.14<\/span>) <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Line 1 has the primary template, line 2 the full specialization for int,<\/span> and line 3 the overload for double. <\/span>Because I’m not interested in the values for the function or function templates, I skipped them: std::string getTypeName(double)<\/span>, for example. The usage of the various functions is quite comfortable. The compiler deduces the types and the correct function or function template is invoked. In the case of the function overloading the compiler prefers the function overloading to the function template when the function overloading is a perfect fit.<\/p>\n![\"functionTemplateSpecialisation\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/02\/functionTemplateSpecialisation.png\")
But where is the big surprise I mentioned in the title of my post? Here it is. <\/span><\/p>\nT.144: Don\u2019t specialize function templates<\/a><\/h2>\n
![\"dimovAbrahams\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/02\/dimovAbrahams.png\")
<\/p>\n