{"id":6250,"date":"2021-11-12T09:00:21","date_gmt":"2021-11-12T09:00:21","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/template-metaprogramming-hybrid-programming\/"},"modified":"2024-07-22T16:06:57","modified_gmt":"2024-07-22T16:06:57","slug":"template-metaprogramming-hybrid-programming","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/template-metaprogramming-hybrid-programming\/","title":{"rendered":"Template Metaprogramming – Hybrid Programming"},"content":{"rendered":"

First of all, hybrid programming is not an official term. I created it to emphasize an exciting aspect of templates. The difference between function arguments and template arguments.<\/p>\n

<\/p>\n

\"TemplateMetaprogramming\"<\/p>\n

I ended my last post, “Template Metaprogramming – How it Works<\/a>” with a riddle. Here is the context for the riddle.<\/p>\n

The Riddle<\/h2>\n

The function power<\/code> and Power<\/code> calculate the pow(2, 10). power<\/code> is executed at run time and Power<\/code> at compile time.<\/p>\n

<\/p>\n

\n
\/\/ power.cpp<\/span>\n\n#include <iostream><\/span>\n\nint<\/span> power<\/span>(int<\/span> m, int<\/span> n) {                               \n    int<\/span> r =<\/span> 1<\/span>;\n    for<\/span>(int<\/span> k =<\/span> 1<\/span>; k <=<\/span> n; ++<\/span>k) r *=<\/span> m;\n    return<\/span> r;                                        \n}\n\ntemplate<\/span><<\/span>int<\/span> m, int<\/span> n><\/span>                              \nstruct<\/span> Power {\n    static<\/span> int<\/span> const<\/span> value =<\/span> m *<\/span> Power<<\/span>m, n-<\/span>1<\/span>>::<\/span>value;\n};\n                          \ntemplate<\/span><<\/span>int<\/span> m><\/span>                                     \nstruct<\/span> Power<<\/span>m, 0<\/span>><\/span> {                                   \n    static<\/span> int<\/span> const<\/span> value =<\/span> 1<\/span>;                       \n};\n\nint<\/span> main<\/span>() {\n\t\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\t\n\t\n    std::<\/span>cout <<<\/span> \"power(2, 10)= \"<\/span> <<<\/span> power(2<\/span>, 10<\/span>) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> \"Power<2,10>::value= \"<\/span> <<<\/span> Power<<\/span>2<\/span>, 10<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\n\t\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n}\n<\/pre>\n<\/div>\n
If you want more details about both functions, read my previous post, “Template Metaprogramming – How it Works<\/a>“.<\/p>\n
So far, so good, but what is happening in the following example?<\/p>\n
<\/p>\n
\n
\/\/ powerHybrid.cpp<\/span>\n\n#include <iostream><\/span>\n\ntemplate<\/span><<\/span>int<\/span> n><\/span>\nint<\/span> Power(int<\/span> m){\n    return<\/span> m *<\/span> Power<<\/span>n-<\/span>1<\/span>><\/span>(m);\n}\n\ntemplate<\/span><><\/span>\nint<\/span> Power<<\/span>0<\/span>><\/span>(int<\/span> m){\n    return<\/span> 1<\/span>;\n}\n\nint<\/span> main() {\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> \"Power<0>(10): \"<\/span> <<<\/span> Power<<\/span>0<\/span>><\/span>(20<\/span>) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> \"Power<1>(10): \"<\/span> <<<\/span> Power<<\/span>1<\/span>><\/span>(10<\/span>) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> \"Power<2>(10): \"<\/span> <<<\/span> Power<<\/span>2<\/span>><\/span>(10<\/span>) <<<\/span> '\\n'<\/span>;\n    \n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}<\/pre>\n<\/div>\n
As expected, Power<\/code> does its job.<\/p>\n
\"powerHybrid\"<\/p>\n
Here is the riddle in short one more: Is Power<\/code> a function or a metafunction?<\/p>\n
Hybrid Programming<\/h2>\n
To make it short.<\/p>\n
The calls Power<0>(10)<\/code>, Power<1>(10)<\/code>, and Power<2>(10)<\/code> use sharp and round brackets and calculate 10 to the power of 0, 1, and 2. This means 0, 1, and 2 are compile-time arguments, and 10 is a run-time argument. To say it differently: Power is, at the same time, a function and a metafunction. Let me elaborate more on this point.<\/p>\n
Power at Run Time<\/h3>\n
First, I can instantiate Power<\/code> for 2, give it the name Power2<\/code> and use it in a for-loop.<\/p>\n
<\/p>\n
\n
\/\/ powerHybridRuntime.cpp<\/span>\n\n#include <iostream><\/span>\n\ntemplate<\/span><<\/span>int<\/span> n><\/span>\nint<\/span> Power(int<\/span> m){\n    return<\/span> m *<\/span> Power<<\/span>n-<\/span>1<\/span>><\/span>(m);\n}\n\ntemplate<\/span><><\/span>\nint<\/span> Power<<\/span>0<\/span>><\/span>(int<\/span> m){\n    return<\/span> 1<\/span>;\n}\n\nint<\/span> main() {\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    auto<\/span> Power2of =<\/span> Power<<\/span>2<\/span>><\/span>;\n\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <=<\/span> 20<\/span>; ++<\/span>i) {\n        std::<\/span>cout <<<\/span> \"Power2of(\"<\/span> <<<\/span> i <<<\/span> \")= \"<\/span>\n                  <<<\/span> Power2of(i)  <<<\/span> '\\n'<\/span>;\n     }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}<\/pre>\n<\/div>\n
Power2o<\/code>f enables it to calculate the squares of 0 … 20 at run time.<\/p>\n
\"powerHybridRuntime\"<\/p>\n
You cannot invoke Power<\/code> with different template arguments in the for-loop. Template instantiation requires a constant expression. To make it short: The following use of Power fails with a compile-time error that “the value of 'i<\/b>' is not usable in a constant expression<\/span><\/code>“.<\/p>\n
<\/p>\n
\n
for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <=<\/span> 20<\/span>; ++<\/span>i) {<\/p>\n
\u00a0\u00a0\u00a0 std::<\/span>cout <<<\/span> “Power<“<\/span> <<<\/span> i <<<\/span> “>(2)= “<\/span> <<<\/span> Power<<\/span>i><\/span>(2<\/span>) <<<\/span> ‘\\n’<\/span>;<\/p>\n
}<\/p>\n<\/div>\n
Honestly, there is a more interesting difference between a function and a metafunction.<\/p>\n
Power at Compile Time<\/h3>\n
When you study the previous program powerHybrid.cpp<\/code> in C++ Insights<\/a>, you see that each usage of Power with a different template argument creates a new type.<\/p>\n
This means that the invocation\u00a0 Power<2>(10)<\/code> causes the recursive template instantiation for Power<1>(10)<\/code>, and Power<0>(10)<\/code>. Here is the output of C++ Insights<\/a>.<\/p>\n
\"TemplateInstantiation\"<\/p>\n
To sum up my observation. Each template instantiation creates a new type.<\/p>\n
Creating New Types<\/h3>\n
When you use a template such as Power<\/code>, std::vector<\/code>, or std::array<\/code>, you can invoke it with two kinds of arguments: function arguments and template arguments. The function arguments go into the round brackets (( ... )<\/code>) and the template arguments go into the sharp brackets (<...><\/code>). The template arguments create new types. Or, to put it the other way around. You can parameterize templates in two ways: at compile time with sharp brackets (<...><\/code>). and at run time with round brackets (( ... )<\/code>.<\/p>\n
<\/p>\n
\n
auto<\/span> res1 =<\/span> Power<<\/span>2<\/span>><\/span>(10<\/span>);                       \/\/ (1)<\/span>\nauto<\/span> res2 =<\/span> Power<<\/span>2<\/span>><\/span>(11<\/span>);                       \/\/ (2)<\/span>\nauto<\/span> rest3 =<\/span> Power<<\/span>3<\/span>><\/span>(10<\/span>);                      \/\/ (3)<\/span>\n\nstd::<\/span>vector<<\/span>int<\/span>><\/span> myVec1(10<\/span>);                    \/\/ (1)<\/span>\nstd::<\/span>vector<<\/span>int<\/span>><\/span> myVec2(10<\/span>, 5<\/span>);                 \/\/ (2)<\/span>\nstd::<\/span>vector<<\/span>double<\/span>><\/span> myDouble(5<\/span>);                \/\/ (3)<\/span>\n\nstd::<\/span>array<<\/span>int<\/span>, 3<\/span>><\/span> myArray1{ 1<\/span>, 2<\/span>, 3<\/span>};          \/\/ (1)<\/span>\nstd::<\/span>array<<\/span>int<\/span>, 3<\/span>><\/span> myArray2{ 1<\/span>, 2<\/span>, 3<\/span>};          \/\/ (2)<\/span>\nstd::<\/span>array<<\/span>double<\/span>, 3<\/span>><\/span> myArray3{ 1.1<\/span>, 2.2<\/span>, 3.3<\/span>}; \/\/ (3)<\/span>\n<\/pre>\n<\/div>\n