![\"dinosaur](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/dinosaur-966869_1280.jpg\")
<\/p>\nYes, you read it correctly. Today, I write about template metaprogramming, programming with types and not values. <\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
The introduction to template metaprogramming in the guidelines ends uniquely: “The syntax and techniques needed are pretty horrendous.”. In accordance, the rules are primarily about dont’s and do not provide much content:<\/p>\n
constexpr<\/code> functions to compute values at compile time<\/a><\/li>\n- T.124: Prefer to use standard-library TMP facilities<\/a><\/li>\n
- T.125: If you need to go beyond the standard-library TMP facilities, use an existing library<\/a><\/li>\n<\/ul>\n
Honestly, I don’t think template metaprogramming is so horrendous, but the syntax still has a lot of potential.<\/p>\n
Let me try to demystify template metaprogramming and write about programming at compile time in general. During this introduction to programming at compile time, I explicitly write about type-traits (T.124: Prefer to use standard-library TMP facilities) <\/a>and constexpr<\/span> functions (T.123: Use constexpr<\/code> functions to compute values at compile time<\/a>) and implicitly refer to the other rules. Here is my plan:<\/p>\nI introduce template metaprogramming, show how the type-traits library allows you to use template metaprogramming in a well-structured and portable way, and how you can use constexpr<\/span> functions to replace template metaprogramming magic with ordinary functions.<\/p>\nTemplate Metaprogramming<\/h2>\n
![\"OverviewTemplateMetaprogramming\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/OverviewTemplateMetaprogramming.png\")
<\/p>\n
How it all started<\/h3>\n
1994 presented Erwin Unruh<\/a> at a C++ committee meeting, a program that didn’t compile. Here is probably the most famous program that was never compiled.<\/p>\n\n\/\/ Prime number computation by Erwin Unruh<\/span>\r\ntemplate<\/span> <<\/span>int<\/span> i><\/span> struct<\/span> D { D(void<\/span>*<\/span>); operator<\/span> int<\/span>(); };\r\n\r\ntemplate<\/span> <<\/span>int<\/span> p, int<\/span> i><\/span> struct<\/span> is_prime {\r\n enum<\/span> { prim =<\/span> (p%<\/span>i) &&<\/span> is_prime<<\/span>(i ><\/span> 2<\/span> ?<\/span> p :<\/span> 0<\/span>), i -<\/span>1<\/span>><\/span> ::<\/span> prim };\r\n };\r\n\r\ntemplate<\/span> <<\/span> int<\/span> i ><\/span> struct<\/span> Prime_print {\r\n Prime_print<<\/span>i-<\/span>1<\/span>><\/span> a;\r\n enum<\/span> { prim =<\/span> is_prime<<\/span>i, i-<\/span>1<\/span>>::<\/span>prim };\r\n void<\/span> f<\/span>() { D<<\/span>i><\/span> d =<\/span> prim; }\r\n };\r\n\r\nstruct<\/span> is_prime<<\/span>0<\/span>,0<\/span>><\/span> { enum<\/span> {prim=<\/span>1<\/span>}; };\r\nstruct<\/span> is_prime<<\/span>0<\/span>,1<\/span>><\/span> { enum<\/span> {prim=<\/span>1<\/span>}; };\r\nstruct<\/span> Prime_print<<\/span>2<\/span>><\/span> { enum<\/span> {prim =<\/span> 1<\/span>}; void<\/span> f<\/span>() { D<<\/span>2<\/span>><\/span> d =<\/span> prim; } };\r\n#ifndef LAST<\/span>\r\n#define LAST 10<\/span>\r\n#endif<\/span>\r\nmain () {\r\n Prime_print<<\/span>LAST><\/span> a;\r\n } \r\n<\/pre>\n<\/div>\n <\/p>\n
Erwin Unruh used the Metaware Compilers, but the program is not valid for C++ anymore. A newer variant from the author is here<\/a>. Okay, why is this program so famous? Let’s have a look at the error messages.<\/p>\n ![\"prim\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/prim.PNG\")
<\/p>\n
I highlighted the important parts in red. I think you see the pattern. The program calculates at compile time the first 30 prime numbers. This means template instantiation can be used to do math at compile time. It is even better. Template metaprogramming is Turing-complete<\/a>, and can, therefore, be used to solve any computational problem. (Of course, Turing completeness holds only in theory for template metaprogramming because the recursion depth (at least 1024 with C++11) and the length of the names generated during template instantiation provide some limitations.)<\/p>\n<\/p>\nHow does the magic work?<\/h3>\n
Let me start traditional.<\/p>\n
Calculating at Compile Time<\/h4>\n
Calculating the factorial of a number is the “Hello World” of template metaprogramming.<\/p>\n
\n\/\/ factorial.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>int<\/span> N><\/span> \/\/ (2)<\/span>\r\nstruct<\/span> Factorial{\r\n static<\/span> int<\/span> const<\/span> value =<\/span> N *<\/span> Factorial<<\/span>N-<\/span>1<\/span>>::<\/span>value;\r\n};\r\n\r\ntemplate<\/span> <><\/span> \/\/ (3)<\/span>\r\nstruct<\/span> Factorial<<\/span>1<\/span>><\/span>{\r\n static<\/span> int<\/span> const<\/span> value =<\/span> 1<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"Factorial<5>::value: \"<\/span> <<<\/span> Factorial<<\/span>5<\/span>>::<\/span>value <<<\/span> std::<\/span>endl; \/\/ (1)<\/span>\r\n std::<\/span>cout <<<\/span> \"Factorial<10>::value: \"<\/span> <<<\/span> Factorial<<\/span>10<\/span>>::<\/span>value <<<\/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
The call factorial<5>:<\/span>:value<\/span> in line (1) causes the instantiation of the primary or general template in line (2). During this instantiation, Factorial<4>:<\/span>:value will be instantiated. This recursion will end if the fully specialised class template Factorial<1><\/span> kicks in in line (3). Maybe, you like it more pictorial.<\/p>\n![\"factorial5\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/factorial5.PNG\")
<\/p>\n
Here is the output of the program:<\/p>\n
![\"factorial\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/01\/factorial.png\")
<\/p>\n
Damn, I almost forgot to prove that the values were calculated at compile time.<\/span><\/span> Here we are with the Compiler Explorer<\/a>. For simplicity reasons, I only provide a screenshot of the main program and the corresponding assembler instructions.<\/p>\n ![\"goldboltSource\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/goldboltSource.png\")
<\/p>\n
![\"goldboltAssem\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/goldboltAssem.png\")
<\/p>\n
<\/p>\n
The first yellow line and the first purple line show it. The factorials of 5 and 10 are just constants and were calculated during compile time. <\/p>\n
The factorial program is friendly but not idiomatic for template metaprogramming.<\/p>\n
Manipulating Types at Compile Time<\/h4>\n
Manipulating types at compile time is typically for template metaprogramming. If you don’t believe me, study std::move<\/a>. <\/span>Here is what std:<\/span>:move is conceptionally doing:<\/span><\/p>\n\nstatic_cast<\/span><<\/span>std::<\/span>remove_reference<<\/span>decltype(arg)>::<\/span>type&&><\/span>(arg);\r\n<\/pre>\n<\/div>\n <\/p>\n
Okay. std::move<\/span> takes an argument arg<\/span>, deduces the type (decltype(arg))<\/span> from it, removes the reference (remove_reverence<\/span>), and casts it to a rvalue reference (static_cast<…>::type&&><\/span>). In essence, this means that std:<\/span>:move returns always a rvalue reference type and, therefore, move semantic can kick it.<\/p>\n