{"id":5659,"date":"2019-04-04T17:01:06","date_gmt":"2019-04-04T17:01:06","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-insights-variadic-templates\/"},"modified":"2019-04-04T17:01:06","modified_gmt":"2019-04-04T17:01:06","slug":"c-insights-variadic-templates","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-insights-variadic-templates\/","title":{"rendered":"C++ Insights – Variadic Templates"},"content":{"rendered":"

Variadic templates are a C++ feature that looks quite magic the first time you see them. Thanks to C++ Insights, most of the magic disappears. <\/p>\n

<\/p>\n

 <\/p>\n

\"04<\/p>\n

Variadic templates are one of the powerful new constructs we have since C++11.<\/p>\n

Variadic Templates<\/h2>\n

They are great because we can have a function that takes multiple arguments and still is strongly typed. We do not need a format specifier to cast some memory from the stack into a type. Variadic templates or in this case more precisely variadic function templates, expand into functions as we would write them. The so-called parameter pack gets expanded. During this process, each parameter is simply separated by a comma, just like we would write the function. Here is a basic example:<\/p>\n

template<\/span><typename<\/span> T>\r\nT add<\/span>(const<\/span> T& arg)<\/span>\r\n<\/span>{\r\n  return<\/span> arg;\r\n}\r\n\r\ntemplate<\/span><typename<\/span> T, typename<\/span>... ARGS>\r\nT add<\/span>(const<\/span> T& arg, const<\/span> ARGS&... args)<\/span>\r\n<\/span>{\r\n  return<\/span> arg + add(args...);\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  return<\/span> add(1<\/span>, 2u<\/span>, 3u<\/span>);\r\n}\r\n<\/code><\/pre>\n
The single argument overload is required to terminate the recursion I used here. Let\u2019s use C++ Insights to see what\u2019s going on under the hood<\/a>:<\/p>\n
template<\/span><typename<\/span> T>\r\nT add<\/span>(const<\/span> T& arg)<\/span>\r\n<\/span>{\r\n  return<\/span> arg;\r\n}\r\n\r\n\/* First instantiated from: insights.cpp:10 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nunsigned<\/span> int<\/span> add<unsigned<\/span> int<\/span>>(const<\/span> unsigned<\/span> int<\/span> & arg)\r\n{\r\n  return<\/span> arg;\r\n}\r\n#endif<\/span><\/span>\r\n\r\n\r\ntemplate<\/span><typename<\/span> T, typename<\/span>... ARGS>\r\nT add<\/span>(const<\/span> T& arg, const<\/span> ARGS&... args)<\/span>\r\n<\/span>{\r\n  return<\/span> arg + add(args...);\r\n}\r\n\r\n\/* First instantiated from: insights.cpp:15 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nint<\/span> add<int<\/span>, unsigned<\/span> int<\/span>, unsigned<\/span> int<\/span>>(const<\/span> int<\/span> & arg, const<\/span> unsigned<\/span> int<\/span> & __args1, const<\/span> unsigned<\/span> int<\/span> & __args2)\r\n{\r\n  return<\/span> static_cast<\/span><int<\/span>>(static_cast<\/span><unsigned<\/span> int<\/span>>(arg) + add(__args1, __args2));\r\n}\r\n#endif<\/span><\/span>\r\n\r\n\r\n\/* First instantiated from: insights.cpp:10 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nunsigned<\/span> int<\/span> add<unsigned<\/span> int<\/span>, unsigned<\/span> int<\/span>>(const<\/span> unsigned<\/span> int<\/span> & arg, const<\/span> unsigned<\/span> int<\/span> & __args1)\r\n{\r\n  return<\/span> arg + add(__args1);\r\n}\r\n#endif<\/span><\/span>\r\n\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  return<\/span> add(1<\/span>, 2u<\/span>, 3u<\/span>);\r\n}\r\n<\/code><\/pre>\n
Pay attention to the types. I used 2u<\/code> and 3u<\/code> which results in two unsigned int<\/code> arguments and one signed int<\/code>. Due to the arrangement of the parameters the return type  add<\/code> is int<\/code> which leads, as C++ Insights shows the use, to an implicit cast in add<\/code>. One additional insight C++ Insights shows us.<\/p>\n<\/p>\n
Fold Expressions<\/h3>\n
With C++17 and fold-expressions we can reduce our code to this:<\/p>\n
template<\/span><typename<\/span>... ARGS>\r\nauto<\/span> add<\/span>(const<\/span> ARGS&... args)<\/span>\r\n<\/span>{\r\n  return<\/span> (args + ...);\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  return<\/span> add(1<\/span>, 2u<\/span>, 3u<\/span>);\r\n}\r\n<\/code><\/pre>\n
template<typename... ARGS>\r\nauto add(const ARGS&... args)\r\n{\r\n  return (args + ...);\r\n}\r\n\r\n\/* First instantiated from: insights.cpp:9 *\/\r\n#ifdef INSIGHTS_USE_TEMPLATE\r\ntemplate<>\r\nunsigned int add<int, unsigned int, unsigned int>(const int & __args0, const unsigned int & __args1, const unsigned int & __args2)\r\n{\r\n  return static_cast<unsigned int>(__args0) + __args1 + __args2;\r\n}\r\n#endif\r\n\r\n\r\nint main()\r\n{\r\n  return static_cast<int>(add(1, 2u, 3u));\r\n}\r\n<\/code><\/pre>\n
Of course, you can write variadic class templates as well. Have a look at this code sample:<\/p>\n
template<\/span><int<\/span>...>\r\nstruct<\/span> add;\r\n\r\ntemplate<\/span><>\r\nstruct<\/span> add<>\r\n{\r\n  static<\/span> constexpr<\/span> int<\/span> value = 0<\/span>;\r\n};\r\n\r\ntemplate<\/span><int<\/span> i, int<\/span>... tail>\r\nstruct<\/span> add<i, tail...>\r\n{\r\n  static<\/span> constexpr<\/span> int<\/span> value = i + add<tail...>::value;\r\n};\r\n\r\nstatic_assert<\/span>(6<\/span> == add<1<\/span>, 2<\/span>, 3<\/span>>::value, \"Expect 6\"<\/span>);\r\n<\/code><\/pre>\n
We have a variadic class template that calculates the sum of an arbitrary amount of numbers. C++ Insights shows all the instantiations that happen in the background to calculate the result. Here we can see how it pops one number each time until there are no more left:<\/p>\n
template<\/span><int<\/span>...>\r\nstruct<\/span> add;\r\n\r\n\/* First instantiated from: insights.cpp:16 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nstruct<\/span> add<1<\/span>, 2<\/span>, 3<\/span>>\r\n{\r\n  inline<\/span> static<\/span> constexpr<\/span> const<\/span> int<\/span> value = 1<\/span> + add<2<\/span>, 3<\/span>>::value;\r\n  \r\n};\r\n#endif<\/span><\/span>\r\n\r\n\r\n\/* First instantiated from: insights.cpp:13 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nstruct<\/span> add<2<\/span>, 3<\/span>>\r\n{\r\n  inline<\/span> static<\/span> constexpr<\/span> const<\/span> int<\/span> value = 2<\/span> + add<3<\/span>>::value;\r\n  \r\n};\r\n#endif<\/span><\/span>\r\n\r\n\r\n\/* First instantiated from: insights.cpp:13 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nstruct<\/span> add<3<\/span>>\r\n{\r\n  inline<\/span> static<\/span> constexpr<\/span> const<\/span> int<\/span> value = 3<\/span> + add<>::value;\r\n  \r\n};\r\n#endif<\/span><\/span>\r\n\r\n\r\ntemplate<\/span><>\r\nstruct<\/span> add<>\r\n{\r\n  static<\/span> constexpr<\/span> int<\/span> value = 0<\/span>;\r\n};\r\n\r\ntemplate<\/span><int<\/span> i, int<\/span>... tail>\r\nstruct<\/span> add<i, tail...>\r\n{\r\n  static<\/span> constexpr<\/span> int<\/span> value = i + add<tail...>::value;\r\n};\r\n\r\n\/* PASSED: static_assert(6 == add<1, 2, 3>::value, \"Expect 6\"); *\/<\/span>\r\n<\/code><\/pre>\n
Reference to an Array<\/h2>\n
One more thing about templates is that they can take a reference to an array which prevents an array from decaying to a pointer:<\/p>\n
template<typename T, int N>\r\nvoid Rx(T (&data)[N])\r\n{\r\n  \/\/ assuming char here\r\n  static_assert(sizeof(data) == 5);\r\n}\r\n\r\nint main()\r\n{\r\n    char buffer[5]{};\r\n\r\n    Rx(buffer);\r\n}\r\n<\/code><\/pre>\n
In C++ Insights you can see that the instantiation contains the type as well as the size of the array<\/a>:<\/p>\n
template<typename T, int N>\r\nvoid Rx(T (&data)[N])\r\n{\r\n  \/\/ assuming char here\r\n  static_assert(sizeof(data) == 5);\r\n}\r\n\r\n\/* First instantiated from: insights.cpp:12 *\/\r\n#ifdef INSIGHTS_USE_TEMPLATE\r\ntemplate<>\r\nvoid Rx<char, 5>(char (&data)[5])\r\n{\r\n  \/* PASSED: static_assert(sizeof(data) == 5); *\/\r\n}\r\n#endif\r\n\r\n\r\nint main()\r\n{\r\n  char buffer[5] = {'\\0', '\\0', '\\0', '\\0', '\\0'};\r\n  Rx(buffer);\r\n}\r\n<\/code><\/pre>\n
Another thing, aside from templates, you can see in this example the effect of braced initialization of buffer. The compiler fills all elements of the array for us with the default value. This means that we can say goodbye to the good old memset<\/code> and make our programs faster and safer.<\/p>\n
I hope I could show you how C++ Insights can be helpful if it comes to templates. For me, it is a vital instrument when teaching and explaining templates, especially variadic templates. Try it out and tell me about your experience.<\/p>\n
I\u2019d like to thank Rainer for the opportunity to share information about C++ Insights on his popular blog!<\/p>\n
Have fun with C++ Insights. You can support the project by becoming a Patreon<\/a> or of course with code contributions<\/a>.<\/p>\n
Stay tuned for more insights about C++ Insight … . The next post is about lambdas.<\/p>\n
Andreas<\/strong><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Variadic templates are a C++ feature that looks quite magic the first time you see them. Thanks to C++ Insights, most of the magic disappears. <\/p>\n","protected":false},"author":21,"featured_media":5658,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[374],"tags":[],"class_list":["post-5659","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cppinsight"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5659","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5659"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5659\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5658"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5659"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5659"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5659"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
I really like how the new standards make us write less and less code. The result of C++ Insights<\/a> changes as well:<\/p>\n