{"id":6245,"date":"2021-11-05T10:35:22","date_gmt":"2021-11-05T10:35:22","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/template-metaprogramming-how-it-works\/"},"modified":"2024-07-22T16:03:50","modified_gmt":"2024-07-22T16:03:50","slug":"template-metaprogramming-how-it-works","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/template-metaprogramming-how-it-works\/","title":{"rendered":"Template Metaprogramming – How it Works"},"content":{"rendered":"

In my last post, “Template Metaprogramming – How it All Started<\/a>“, I wrote about the roots of template metaprogramming. I presented the hello world of template metaprogramming: calculating the factorial of a number at compile time. In this post, I will write about how template metaprogramming can modify types at compile time.<\/p>\n

<\/p>\n

\"TemplateMetaprogramming\" The factorial program in the last post, “Template Metaprogramming – How it All Started<\/a>” was an excellent example but not idiomatic for template metaprogramming. Manipulating types at compile time is typical in template metaprogramming.<\/p>\n

Type Manipulation at Compile Time<\/h2>\n

For example, here is what std::move<\/a> is conceptionally doing:<\/p>\n

<\/p>\n

\n
static_cast<\/span><<\/span>std::<\/span>remove_reference<<\/span>decltype(arg)>::<\/span>type&&><\/span>(arg);\n<\/pre>\n<\/div>\n
std::move<\/code> takes its argument arg<\/code>, deduces its type (decltype(arg))<\/code>, removes its reference (std::remove_reverence<\/code>), and casts it to an rvalue reference (static_cast<...>::type&&><\/code>). Essentially,
\nstd::move<\/code> is an rvalue reference cast. Now, move semantics can kick in.<\/p>\n
How can a function remove constness from its argument?<\/p>\n
<\/p>\n
\n
\/\/ removeConst.cpp<\/span>\n\n#include <iostream><\/span>\n#include <type_traits><\/span>\n\ntemplate<\/span><<\/span>typename<\/span> T ><\/span>\n    struct<\/span> removeConst {\n    using<\/span> type =<\/span> T;        \/\/ (1)<\/span>\n};\n\ntemplate<\/span><<\/span>typename<\/span> T ><\/span>\n    struct<\/span> removeConst<<\/span>const<\/span> T><\/span> {\n    using<\/span> type =<\/span> T;       \/\/ (2)<\/span>\n};\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\n    std::<\/span>cout <<<\/span> std::<\/span>is_same<<\/span>int<\/span>, removeConst<<\/span>int<\/span>>::<\/span>type>::<\/span>value <<<\/span> '\\n'<\/span>;       \/\/ true<\/span>    \n    std::<\/span>cout <<<\/span> std::<\/span>is_same<<\/span>int<\/span>, removeConst<<\/span>const<\/span> int<\/span>>::<\/span>type>::<\/span>value <<<\/span> '\\n'<\/span>; \/\/ true<\/span>\n\n}\n<\/pre>\n<\/div>\n
I implemented removeConst<\/code> the way std::remove_const<\/code> is probably implemented in the type-traits library<\/a>. std::is_same<\/code> from the type-traits library helps me to decide at compile-time if both types are the same. In case of removeConst<int><\/code> the primary or general class template kicks in; in case of removeConst<const int><\/code>, the partial specialization for const T<\/code> applies. The critical observation is that both class templates return the underlying type in (1) and (2) via the alias type<\/code>. As promised, the constness of the argument is removed.<\/p>\n
There are additional observations:<\/p>\n