![\"TemplateSpecialization\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/06\/TemplateSpecialization.png\")
<\/p>\nTemplates define the behavior of families of classes or functions. Often it is required that particular types or non-types may be treated special. To support this use case, you can specialize templates.<\/p>\n
<\/p>\n
<\/p>\n
Let me start this post with the general idea of template specialization. In the next post, I concentrate on the details.<\/p>\n<\/p>\n
Templates define the behavior of families of classes and functions. Often it is required that particular types or non-types must be treated special. Therefore, you can fully specialize templates.<\/p>\n
Class templates can also be partially specialized. The general or primary template can coexist with partially or fully specialized templates. The member functions and attributes of specialization don\u2019t have to be identical to those of the primary template. The compiler prefers fully specialized to partially specialized templates and partially specialized templates to primary templates.<\/p>\n
The following example should clarify my words.<\/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
\n- Primary Template<\/li>\n<\/ul>\n
Line 1 is the primary or general template. The primary template has to be declared before the partially or fully specialized templates. If the primary template is unnecessary, a declaration such as in line 1 is acceptable.<\/p>\n
\n- Partial Specialization<\/li>\n<\/ul>\n
Line 2 follows with the partial specialization. Only class templates support partial specialization. A partial specialization has template parameters and explicitly specified template arguments. In the concrete case, class Matrix<T, 3, 3> T<\/code> is the template parameter, and the numbers are the template arguments.<\/p>\n\n- Full Specialization<\/li>\n<\/ul>\n
Line 3 is the full specialization. Full means that all template arguments are specified and the template parameter list is empty: template <><\/code> in line 3.<\/p>\nPartial versus Full Specialization<\/h3>\n
To better understand partial and full specialization, I want to present a visual explanation. You may know I studied mathematics, and I had many linear systems of equations to solve.<\/p>\n
Think about an n-dimensional space of template parameters. A partial specialization is a subspace in the n-dimensional space, and a full specialization is a point in the n-dimensional space.<\/p>\n
I apply my visual explanation to the class template Matrix<\/code> and its partial and full specialization. In the primary template (line 1), you can choose a type as a template parameter and two int<\/code> values as non-type template parameters. Regarding the partial specialization in line 2, you can only choose the type. This means the 3-dimensional space is reduced to a line. The partial specialization of the primary template Matrix<\/code> is, therefore, a subspace of the 3-dimensional space. The full specialization (line 3) is a point in the 3-dimensional space. <\/p>\nWhat happens when you invoke the templates?<\/p>\n
Using the Primary, Partial, and Full Specialization<\/h3>\n
To remind you, the following specializations of the class Matrix<\/code> are given.<\/p>\n\ntemplate<\/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
The question is: What happens when you instantiate Matrix<\/code> for various template arguments? Here are three instantiations, and you see what the compiler creates.<\/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 entire specialization, m2<\/span> uses the partial specialization, and m3<\/span> uses the primary template, which causes an error because the definition is missing.<\/p>\nTo understand this process, you must remember a few rules. Here are the rules that apply, in particular, to the partial specialization of class templates.<\/p>\n
Dependencies between the Template Parameter and the Template Arguments<\/h4>\n\n- The number and sequence of the explicitly specified template arguments (
<T, 3, 3><\/code>) must match the number and sequence of the template parameter list (<typename T, int Line, int Column><\/code>) of the primary template.<\/li>\n- If you use defaults for template parameters, you don’t have to provide the template arguments. Only the primary template accepts defaults for template parameters.<\/li>\n<\/ul>\n
Valid Partial Specializations<\/h4>\n\n- The compiler chooses a partial specialization if the template instantiation arguments
(Matrix<double, 3, 3><\/code>) are a subset of the template arguments of the partial specialization (Matrix<T, 3, 3><\/code>).<\/li>\n<\/ul>\nChosen Template Specialization<\/h4>\n\n- The compiler finds only one specialization. The compiler uses this specialization.<\/li>\n
- The compiler finds more than one specialization. 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 specialization. It uses the primary specialization.<\/li>\n<\/ol>\n
Okay, there is one question left I have to answer. What does it mean that a template A<\/code> is a more specialized template than another template B<\/code>. This is my informal definition.
<\/em><\/p>\nA template A is more specialized than a template B:<\/strong><\/p>\n