![\"templates\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/templates.png\")
<\/p>\nThere is a lot of power in the strange-looking three dots that are heavily used in the Standard Template Library. Today, I visualize the expansion of the three dots and show a few use cases.<\/p>\n
<\/p>\n
<\/p>\n
Let me start this post by analyzing the pack expansion in variadic templates.<\/p>\n
Here is a short reminder.<\/p>\n
A variadic template is a template that can have an arbitrary number of template parameters.<\/p>\n
<\/p>\n
template<\/span> <<\/span>typename<\/span> ... Args><\/span>\nvoid<\/span> variadicTemplate(Args ... args) { \n . . . . \/\/ four dots<\/span>\n}\n<\/pre>\n<\/div>\nThe ellipsis (...<\/code>) makes Args<\/code> or args<\/code> a so-called parameter pack. Precisely, Args<\/code> is a template parameter pack and args <\/code>a function parameter pack. Two operations are possible with parameter packs. They can be packed and unpacked. If the ellipse is to the left of Args<\/code>, the parameter pack will be packed; if it is to the right of Args<\/code>, it will be unpacked. Because of the function template argument deduction, the compiler can derive the template arguments.<\/p>\nBefore I write about the pack expansion, I have to make a short disclaimer. Usually, you don’t apply pack expansion directly. You use variadic templates doing it automatically, using fold expression, or constexpr if<\/code><\/a> in C++17. I will write about fold expressions and constexpr if<\/code> in future posts. Visualizing pack expansions helps a lot for a better understanding of variadic templates and fold expressions.<\/p>\nThe usage of parameter packs obeys a typical pattern for class templates.<\/p>\n
\n- Operate on the first element of the parameter pack and recursively invoke the operation on the remaining elements. This step reduces the parameter pack successively by its first element.<\/li>\n
- The recursion ends after a finite number of steps.<\/li>\n
- The boundary condition is typically a fully specialized template.<\/li>\n<\/ul>\n
Thanks to this functional pattern for processing lists, you can calculate the product of numbers at compile time. In Lisp, you call the head of the list ca<\/code>r, and the rest cdr<\/code>. In Haskell, you call it head<\/code> and tail<\/code>.<\/p>\n<\/p>\n
\n\/\/ multVariadicTemplates.cpp<\/span>\n\n#include <iostream><\/span>\n\ntemplate<\/span><<\/span>int<\/span> ...> <\/span> \/\/ (1)<\/span><\/em>\nstruct<\/span> Mult;\n\ntemplate<\/span><> <\/span>\/\/ (2)<\/span>\nstruct<\/span> Mult<><\/span> {\n static<\/span> const<\/span> int<\/span> value =<\/span> 1<\/span>;\n};\n\ntemplate<\/span><<\/span>int<\/span> i, int<\/span> ... tail> \/\/ (3)<\/span><\/span>\nstruct<\/span> Mult<<\/span>i, tail ...><\/span> {\n static<\/span> const<\/span> int<\/span> value =<\/span> i *<\/span> Mult<<\/span>tail ...>::<\/span>value;\n};\n\nint<\/span> main<\/span>(){\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n std::<\/span>cout <<<\/span> \"Mult<10>::value: \"<\/span> <<<\/span> Mult<<\/span>10<\/span>>::<\/span>value <<<\/span> '\\n'; \/\/ (4)<\/span><\/em>\n std::<\/span>cout <<<\/span> \"Mult<10,10,10>::value: \"<\/span> <<<\/span> Mult<<\/span>10<\/span>, 10<\/span>, 10<\/span>>::<\/span>value <<<\/span> '\\n';\n std::<\/span>cout <<<\/span> \"Mult<1,2,3,4,5>::value: \"<\/span> <<<\/span> Mult<<\/span>1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>>::<\/span>value <<<\/span> '\\n';\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\n<\/code><\/code>The class template Mult<\/code> consists of a primary template and two specializations. Since the primary template (1) is not needed, a declaration is sufficient in this case: template<int ...> struct Mult<\/code>. The specializations of the class template exist for no element (2) and at least one element (3). If Mult<10,10,10>::value<\/code> is called, the last template is used by successively calling the first element with the rest of the parameter pack so that the value expands to the product 10*10*10. In the final recursion, the parameter pack contains no elements, and the boundary condition comes into action: template<> struct Mult<><\/code> (1). This returns the result of Mult<10,10,10>::value= 10*10*10*1<\/code> at compile time.<\/p>\n![\"multVariadicTemplates\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/multVariadicTemplates.png\")
<\/p>\n
Now, to the exciting part: What happens under the hood? Let’s have a closer look at the call Mult<10,10,10>::value<\/code>. This call triggers no recursion but a recursive instantiation. Here are the essential parts from C++ Insights<\/a>:<\/p>\n![\"multInstantiation\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/multInstantiation.png\")
The compiler generates full specializations for three (Mult<10, 10, 10><\/code>) and two arguments (Mult<10, 10><\/code>). You may ask yourself: Where are the instantiations for one (Mult<10><\/code>) and no argument (Mult<><\/code>). Mult<10><\/code> was already requested in (4) and Mult<><\/code> (1) is the boundary condition.<\/p>\nLet me continue with an anecdote. When introducing <\/code>variadic templates, I ask my participants: Who of you ever used an ellipse? Half of my participants answer never. I answered them that I didn’t believe them and they may be heard from the printf <\/a>family.<\/p>\nA Type-Safe printf<\/code> Function<\/h3>\nOf course, you know the C function printf: int<\/span> printf(<\/span> const<\/span> char<\/span>*<\/span> format, ... )<\/span><\/code>;. printf<\/code> is a function that can get an arbitrary number of arguments. Its power is based on the macro va_arg <\/a>and is not type-safe. Let’s implement a simplified printf<\/code> function using variadic templates. This function is the<\/span><\/span> <\/code>hello world of variadic templates.<\/p>\n\n\/\/ myPrintf.cpp<\/span>\n\n#include <iostream><\/span>\n \nvoid<\/span> myPrintf<\/span>(const<\/span> char<\/span>*<\/span> format){ \/\/ (3)<\/span>\n std::<\/span>cout <<<\/span> format;\n}\n \ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> ... Args><\/span>\nvoid<\/span> myPrintf(const<\/span> char<\/span>*<\/span> format, T value, Args ... args){ \/\/ (4)<\/span>\n for<\/span> ( ; *<\/span>format !=<\/span> '\\0'<\/span>; format++<\/span> ) { \/\/ (5)<\/span>\n if<\/span> ( *<\/span>format ==<\/span> '%'<\/span> ) { \/\/ (6) <\/span>\n std::<\/span>cout <<<\/span> value;\n myPrintf(format +<\/span> 1<\/span>, args ... ); \/\/ (7)<\/span>\n return<\/span>;\n }\n std::<\/span>cout <<<\/span> *<\/span>format; \/\/ (8)<\/span>\n }\n}\n \nint<\/span> main(){\n \n myPrintf(\"<\/span>\\n<\/span>\"<\/span>); \/\/ (1)<\/span>\n \n myPrintf(\"% world% %<\/span>\\n<\/span>\"<\/span>, \"Hello\"<\/span>, '!'<\/span>, 2011<\/span>); \/\/ (2)<\/span>\n \n myPrintf(\"<\/span>\\n<\/span>\"<\/span>); \n \n}\n<\/pre>\n<\/div>\nHow does the code work? If myPrintf<\/span> is invoked without a format string (1), (3) is used in the case. (2) uses the function template. The function templates loops (5) as long as the format symbol does not equal `\\0`<\/span>. If the format symbol is not equal to `\\0<\/span> , two control flows are possible. First, if the format starts with ‘%<\/span>‘\u00a0 (6), the first argument value<\/span> is displayed, <\/span>and myPrintf<\/span> is once more invoked, but this time with a new format symbol and an argument less (7). Second, if the format string does not start with\u00a0'%<\/span><\/code>‘, the format symbol is just displayed (line 8). The function myPrintf<\/span> (3) is the boundary condition for the recursive calls.<\/p>\nThe output of the program is as expected.<\/p>\n
![\"myPrintf\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/12\/myPrintf.png\")
<\/p>\n
![\"fourArguments\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/fourArguments.png\")
<\/p>\n![\"threeArguments\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/threeArguments.png\")
<\/p>\n![\"twoArguments\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/twoArguments.png\")
<\/p>\n