![\"theater](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/12\/theater-311730_1280.png\")
<\/p>\nVariadic templates are a typical feature of C++: from the user’s perspective, they are easy to use, but from the implementor’s perspective, they look pretty scary. Today’s post is mainly about the implementor’s perspective.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Before I write about the details of variadic temples, I want to mention my introduction to this post briefly. I often wear two heads when I teach C++: one for the user and one for the implementor. Features such as templates are easy to use but challenging to implement. This significant gap is typically for C++ and, I assume, more profound than in other mainstream programming languages such as Python, Java, or C. Honestly, I have no problem with this gap. I call this gap abstraction, and it is an essential part of the power of C++. The art of the implementer of the library or framework is to provide easy-to-use (complicated to misuse) and stable interfaces. If you don’t get the point, wait for the next section, when I develop std::make_unique<\/span>.<\/p>\n Today’s post is based on three rules:<\/p>\n You can already guess it. The three rules are title-only; therefore, I make one story out of the first three.<\/p>\n As promised, I want to develop std::make_unique. std::make_unique<\/span> is a function template that returns a dynamically allocated object protected by a std::unique_ptr<\/span>. Let me show you a few use cases. <\/p>\n Based on this use case, what are the requirements of std::make_unique<\/span>?<\/p>\n These requirements are typically for factory functions such as std::make_unique, std::make_shared, std::make_tupl<\/span>e, and std::thread. <\/span>Both rely on two powerful features of C++11:<\/p>\n Now, I want to create my factory function createT.<\/span> Let me start with perfect forwarding.<\/p>\n<\/p>\n First of all: What is perfect forwarding?<\/p>\n Perfect forwarding follows a typical pattern consisting of a universal reference and std::forward.<\/span><\/p>\n <\/p>\n The three parts of the pattern to get perfect forwarding are:<\/p>\n The key observation is that T&& (line 2) can bind an lvalue or an rvalue and that std::forward<\/span> (line 3) does the perfect forwarding.<\/p>\n It’s time to create the prototype of the createT<\/span> factory function, which should behave at the end, such as makeUnique.cpp<\/span>. I just replaced std::make_unique<\/span> with the createT<\/span> call, added the createT<\/span> factory function, and commented the lines (1) and (4) out. Additionally, I removed the header <memory><\/span> (std::make_unique<\/span>) and added the header <utility><\/span>(std::foward<\/span>). <\/p>\n <\/p>\n Fine. An rvalue (line 2) and an lvalue (line 3) pass my test.<\/p>\n Sometimes dots are essential. Putting exactly nine dots at the right place and line (1) and line (4) work.<\/p>\n <\/p>\n <\/p>\n How does the magic work? The three dots stand for an ellipse. By using them Args,<\/span> or args<\/span> become a parameter pack. To be more precise, Args i<\/span>s a template parameter pack, and args<\/span> is a function parameter pack. You can only apply two operations to a parameter pack: you can pack or unpack it. If the ellipse is left of Args<\/span> the parameter pack is packed; if the ellipse is right of Args<\/span> the parameter pack is unpacked. In the case of the expression (std::forward<Args>(args)…<\/span>) this means the expression is unpacked until the parameter pack is consumed, and a comma is just placed between the unpacked components. This was all.<\/p>\n\n
<\/span><\/p>\n\n\/\/ makeUnique.cpp<\/span>\r\n\r\n#include <memory><\/span>\r\n\r\nstruct<\/span> MyType{\r\n MyType(int<\/span>, double<\/span>, bool<\/span>){};\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n int<\/span> lvalue{2020<\/span>};\r\n \r\n std::unique_ptr<int> <\/span><\/span><\/span><\/span>uniqZero =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(); \/\/ (1)<\/span>\r\n auto<\/span> uniqEleven =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(2011<\/span>); \/\/ (2)<\/span>\r\n auto<\/span> uniqTwenty =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(lvalue); \/\/ (3)<\/span>\r\n auto<\/span> uniqType =<\/span> std::<\/span>make_unique<<\/span>MyType><\/span>(lvalue, 3.14<\/span>, true<\/span>); \/\/ (4)<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n\n
\n
Perfect Forwarding<\/h2>\n
\n
const<\/code>\/volatile<\/code> modifiers.<\/li>\n<\/ul>\n\ntemplate<\/span><<\/span>typename<\/span> T<\/span>><\/span> \/\/ (1)<\/span>\r\nvoid<\/span> create(T&&<\/span> t){ \/\/ (2)<\/span>\r\n std::<\/span>forward<<\/span>T><\/span>(t); \/\/ (3)<\/span>\r\n}\r\n<\/pre>\n<\/div>\n\n
<\/span><\/p>\n\n\/\/ createT1.cpp<\/span>\r\n\r\n#include <utility><\/span>\r\n\r\nstruct<\/span> MyType{\r\n MyType(int<\/span>, double<\/span>, bool<\/span>){};\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> Arg><\/span>\r\nT createT(Arg&&<\/span> arg){\r\n return<\/span> T(std::<\/span>forward<<\/span>Arg><\/span>(arg));\r\n}\r\n \r\nint<\/span> main(){\r\n \r\n int<\/span> lvalue{2020<\/span>};\r\n \r\n \/\/std::unique_ptr<int> uniqZero = std::make_unique<int>(); \/\/ (1)<\/span>\r\n auto<\/span> uniqEleven =<\/span> createT<<\/span>int<\/span>><\/span>(2011<\/span>); \/\/ (2)<\/span>\r\n auto<\/span> uniqTwenty =<\/span> createT<<\/span>int<\/span>><\/span>(lvalue); \/\/ (3)<\/span>\r\n \/\/auto uniqType = std::make_unique<MyType>(lvalue, 3.14, true); \/\/ (4)<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\nVariadic Templates<\/h2>\n
\n\/\/ createT2.cpp<\/span>\r\n\r\n#include <utility><\/span>\r\n\r\nstruct<\/span> MyType{\r\n MyType(int<\/span>, double<\/span>, bool<\/span>){};\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> ... Args><\/span>\r\nT createT(Args&&<\/span> ... args){\r\n return<\/span> T(std::<\/span>forward<<\/span>Args><\/span>(args) ... );\r\n}\r\n \r\nint<\/span> main(){\r\n \r\n int<\/span> lvalue{2020<\/span>};\r\n \r\n int<\/span> uniqZero =<\/span> createT<<\/span>int<\/span>><\/span>(); \/\/ (1)<\/span>\r\n auto<\/span> uniqEleven =<\/span> createT<<\/span>int<\/span>><\/span>(2011<\/span>); \/\/ (2)<\/span>\r\n auto<\/span> uniqTwenty =<\/span> createT<<\/span>int<\/span>><\/span>(lvalue); \/\/ (3)<\/span>\r\n auto<\/span> uniqType =<\/span> createT<<\/span>MyType><\/span>(lvalue, 3.14<\/span>, true<\/span>); \/\/ (4)<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n
![\"createT2](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/12\/createT2_1.png\")
<\/p>\n![\"createT2](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/12\/createT2_2.png\")
<\/p>\n