![\"FoldExpressions\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/09\/templates.png\")
<\/p>\nTo complete my post about variadic templates and fold expressions, I present in this post smart tricks using parameter packs and fold expressions.<\/p>\n
<\/p>\n
<\/p>\n
Fold expressions enable it to reduce a parameter pack with a binary operator. Thanks to them, you can write concise expressions for repeated operations. This repeated operation can be a print function or a push_back function to push elements onto a vector. Let me start with the print function.<\/p>\n
<\/p>\n
\/\/ printFoldExpressions.cpp<\/span>\n\n#include <iostream><\/span>\n#include <string><\/span>\n\ntemplate<\/span><<\/span>typename<\/span> ... Args><\/span>\nvoid<\/span> printMe(Args&&<\/span> ... args) {\n (std::<\/span>cout <<<\/span> ... <<<\/span> std::<\/span>forward<<\/span>Args><\/span>(args)) <<<\/span> '\\n'<\/span>;\n}\n\nint<\/span> main() {\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\n\n printMe();\n printMe(\"Rainer \"<\/span>, \"Grimm\"<\/span>);\n printMe(true<\/span>, \" \"<\/span>, \"+\"<\/span>, \" \"<\/span>,false<\/span>, \" = \"<\/span>, true<\/span> +<\/span> false<\/span>);\n \n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\nThe printMe <\/code>function can accept an arbitrary number of arguments. In the concrete function, this means no argument, two C-strings, and a few strings and numbers. The printMe<\/code> function automatically deduces their types and displays them. Three powerful C++ techniques are involved.<\/p>\n\n- Variadic templates (
...<\/code> ): accepts an arbitrary number of arguments. Read more here: “Variadic Templates or the Power of Three Dots<\/a>” and “More about Variadic Templates<\/a>“.<\/li>\n- Perfect forwarding (
std::forward<\/code>): forwards the arguments without changing their value category. Read more here: Perfect Forwarding<\/a>.<\/li>\n- Fold expressions
(std::cout << ... << std::forward<Args>(args)<\/code>): reduces the parameter pack from the left using the binary operator <<<\/code> and the initial value std::cout<\/code>. Read more here: From Variadic Templates to Fold Expressions<\/a>.\u00a0
\n<\/code><\/li>\n<\/ul>\nFinally, here is the output of the program. ![\"printFoldExpressions\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/09\/printFoldExpressions.png\")
<\/p>\n
Thanks to fold expressions, you can push an arbitrary number of arguments onto a vector.<\/p>\n
<\/p>\n
\n\/\/ pushBackFoldExpressions.cpp<\/span>\n\n#include <iostream><\/span>\n#include <string><\/span>\n#include <vector><\/span>\n\nusing<\/span> namespace<\/span> std;\n \ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span>... Args><\/span>\nvoid<\/span> myPushBack(vector<<\/span>T>&<\/span> v, Args&&<\/span>... args) {\n (v.push_back(args), ...); \/\/ (1)<\/span>\n}\n\nint<\/span> main() {\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n std::<\/span>vector<<\/span>int<\/span>><\/span> myIntVec;\n\tmyPushBack(myIntVec, 1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>);\n\tfor<\/span> (auto<\/span> v :<\/span> myIntVec) std::<\/span>cout <<<\/span> v <<<\/span> ' '<\/span>;\n\n std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n\n std::<\/span>vector myDoubleVec{1.1<\/span>, 2.2<\/span>, 3.3<\/span>}; \/\/ (2)<\/span>\n myPushBack(myDoubleVec, 4.4<\/span>, 5.5<\/span>, 6.6<\/span>);\n for<\/span> (auto<\/span> v:<\/span> myDoubleVec) std::<\/span>cout <<<\/span> v <<<\/span> ' '<\/span>;\n\n std::<\/span>cout <<<\/span> \"\\n\\n\"<\/span>;\n\n}\n<\/pre>\n<\/div>\nLines (1) and (2) are the most interesting ones. (2) pushes the three doubles onto the vector. With C++17, the compiler can automatically deduce the types of arguments. The expression (v.push_back(args),...)<\/code> pushes the elements from the right using the binary comma operator (,<\/code>). Alternatively, I could also push from the left (..., v.push_back(args))<\/code>, because the comma operator is associative. Honestly, this looks weird. Therefore, I prefer the first variant.<\/p>\nThe following screenshot shows the program output.<\/p>\n
![\"pushBackFoldExpressions\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/09\/pushBackFoldExpressions.png\")
<\/p>\n
Now, I want to go one stack back from fold expressions to variadic templates and present the overload pattern. The overload pattern is a clever way to wrap multiple lambdas into an overload set.<\/p>\n