![\"Overview\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/06\/Overview.png\")
<\/p>\nToday, I will continue my introduction to programming at compile time. The last post started with template metaprogramming. Here is where I pick up today and finish.<\/p>\n
<\/p>\n
Here is the big picture, before I dive in.<\/p>\n
<\/p>\n
<\/p>\n
Only to remind you, the rules of the C++ Core Guidelines were my starting point:<\/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
We are just at the bottom of the triangle.<\/p>\n
Template Metaprogramming<\/h2>\n
In the last post C++ Core Guidelines: Rules for Template Metaprogramming<\/a>, I present a short template metaprogram that removed the constness from its arguments.<\/p>\n <\/p>\n
\ntemplate<\/span><<\/span>typename<\/span> T><\/span> \/\/ (2)<\/span>\r\nstruct<\/span> removeConst{ \r\n typedef<\/span> T type; \/\/ (5)<\/span>\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span> \/\/ (4)<\/span>\r\nstruct<\/span> removeConst<<\/span>const<\/span> T><\/span> { \r\n typedef<\/span> T type; \/\/ (5)<\/span>\r\n};\r\n\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>is_same<<\/span>int<\/span>, removeConst<<\/span>int<\/span>>::<\/span>type>::<\/span>value; \/\/ true (1)<\/span>\r\n std::<\/span>is_same<<\/span>int<\/span>, removeConst<<\/span>const<\/span> int<\/span>>::<\/span>type>::<\/span>value; \/\/ true (3)<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
What can we learn from this example?<\/p>\n
\n- Template specialization (partial or full) is a compile-time if. More specifically, when I use removeConst<\/span> with a non-constant int<\/span> (line 1), the compiler chooses the primary or general template (line 2). When I use a constant int<\/span> (line 3), the compiler chooses the partial specialization for const T<\/span> (line 4). <\/li>\n
- The expression typedef T type<\/span> serves as a return value which is, in this case, a type.<\/li>\n<\/ol>\n
Now, it has become funny.<\/p>\n<\/p>\n
More Meta<\/h3>\n
At runtime, we use data and functions. At compile time, we use metadata and metafunctions. Relatively easy, it’s called meta because we do metaprogramming, but what is metadata or a metafunction? Here is the first definition.<\/p>\n
\n- Metadata<\/strong>: Types and integral values that are used in metafunctions.<\/li>\n
- Metafunction<\/strong>: Functions that are executed at a compile-time.<\/li>\n<\/ul>\n
Let me elaborate more on the terms metadata and metafunction.<\/p>\n
Metadata<\/h4>\n
Metadata includes three entities:<\/p>\n
\n- Types such as int, <\/span>or double.<\/span><\/li>\n
- Non-types such as integrals, enumerators, pointers, or references<\/li>\n
- Templates such as std::stack<\/span><\/a><\/li>\n<\/ol>\n
As I mentioned, I use only types and integrals in my examples of Template Metaprogramming.<\/p>\n
Metafunction<\/h4>\n
Of course, this sounds strange. Types are used in template metaprogramming to simulate functions. Based on my definition of metafunctions, constexpr<\/span> functions which can be executed at compile time, are also metafunctions, but this is my topic for a later post.<\/p>\nHere are two types you already know from my last post C++ Core Guidelines: Rules for Template Metaprogramming<\/a>: Factorial<\/span> and RemoveConst.<\/span><\/p>\n <\/p>\n
\ntemplate<\/span> <><\/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\ntemplate<\/span><<\/span>typename<\/span> T ><\/span> \r\nstruct<\/span> removeConst<<\/span>const<\/span> T><\/span> { \r\n typedef<\/span> T type; \r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
![\"power\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/01\/power.png\")
<\/p>\n