{"id":6170,"date":"2021-06-29T12:18:15","date_gmt":"2021-06-29T12:18:15","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/template-specialization-more-details\/"},"modified":"2021-06-29T12:18:15","modified_gmt":"2021-06-29T12:18:15","slug":"template-specialization-more-details","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/template-specialization-more-details\/","title":{"rendered":"Template Specialization – More Details About Class Templates"},"content":{"rendered":"

After I presented in my last post Template Specialization<\/a>, the basics about template specialization, I dig deeper today. I want to present the partial and full specialization of a class template as a compile-time if.<\/p>\n

<\/p>\n

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

Specialization of Class Templates as a Compile-Time if<\/h2>\n

After my last blog post Template Specialization<\/a>, I got a few similar questions. How can you decide if a type is a given type or if two are the same? Answering these questions is easier and helps me present more theories about class template specialization. To answer these questions, I implement simplified versions of std::is_same<\/code><\/a> , and std::remove_reference<\/a>. The presented techniques in this post apply class template specialization and are a compile-time if.<\/p>\n

std::is_same<\/code><\/h3>\n

std::is_same<\/code> is a function from the type-traits library. It returns std::true_type<\/a> if both types are the same, otherwise, it returns std::false<\/code>_type. For simplicity reasons, I return true<\/code> or false<\/code>.<\/p>\n

<\/p>\n

\n
\/\/ isSame.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> U><\/span>                 \/\/ (1)<\/span>\r\nstruct<\/span> isSame {\r\n    static<\/span> constexpr bool<\/span> value =<\/span> false<\/span>;\r\n};\r\n \r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>                             \/\/ (2)<\/span>\r\nstruct<\/span> isSame<<\/span>T, T><\/span> {\r\n    static<\/span> constexpr bool<\/span> value =<\/span> true<\/span>;\r\n}; \r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;                          \r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\r\n                                                \/\/ (3)<\/span>\r\n    std::<\/span>cout <<<\/span> \"isSame<int, int>::value: \"<\/span> <<<\/span> isSame<<\/span>int<\/span>, int<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"isSame<int, int&>::value: \"<\/span> <<<\/span> isSame<<\/span>int<\/span>, int<\/span>&>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  \r\n                                                \r\n    int<\/span> a(2011<\/span>);\r\n    int<\/span>&<\/span> b(a);                                  \/\/ (4)<\/span>\r\n    std::<\/span>cout <<<\/span> \"isSame<decltype(a), decltype(b)>::value \"<\/span> <<<\/span> \r\n                  isSame<<\/span>decltype(a), decltype(b)>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The primary template (1) returns as the default false<\/code>, when you ask for its value. <\/code>On the contrary, the partial specialization (2) that is used when both types are the same returns true<\/code>. You can use the class template isSame<\/code> on types (3) and, thanks to decltype<\/code>, on values (4). The following screenshot shows the output of the program.<\/p>\n
\"isSame\"<\/p>\n
You may already guess it. The class template isSame<\/code> is an example of template metaprogramming. Now, I have to make a short detour and write a few meta words.<\/p>\n<\/p>\n
Metafunctions and Metadata<\/h3>\n
At runtime, we use data and functions. At compile time, we use metadata and metafunctions. Quite easy, it’s called meta because we do metaprogramming, but what is metadata or a metafunction? Here is the first definition.<\/p>\n