![\"templates\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/templates.png\")
<\/p>\nA variadic template is a template that can have an arbitrary number of template parameters. If you see it for the first time, this feature may seem magical to you. So, let me demystify variadic templates.<\/p>\n
<\/p>\n
<\/p>\n
You may wonder if my graphic showing the topics I write about includes template instantiation. The reason is simple. After my last post about “Template Instantiation<\/a>“, one of my German readers (pseudonym Urfahraner Auge) <\/span>commented. There is an essential difference between implicit and explicit instantiation of a template that I forgot to mention. He is right. The implicit instantiation of templates is lazy, but the explicit instantiation of templates is eager.<\/p>\n Template instantiation is lazy. <\/p>\n If you call the member function I have to explain template instantiation more precisely: The implicit instantiation of templates is lazy, but the explicit instantiation of templates is eager. <\/strong><\/p>\n When you enable line (2) ( I’m keen to get comments about my posts. They help me to write about the content I want to hear. In particular, the German community is very engaged.<\/p>\n Now, finally, to something completely different: variadic templates.<\/p>\n A variadic template is a template that can have an arbitrary number of template parameters. If you see it for the first time, this feature may seem magical.<\/p>\n <\/p>\n The ellipsis ( Variadic templates are often used in the Standard Template Library and the core language.<\/p>\n <\/p>\n All four examples from the C++11 standard use variadic templates. The first three are part of the Standard Template Library. Let’s see what I can deduce from the declarations.<\/p>\n The Thanks to the <\/p>\n The Lazy versus Eager Template Instantiation<\/h2>\n
<\/code>It will not be instantiated if you don’t need a member function of a class template. Only the member function declaration is available, but its definition is not. This works so far that you can use an invalid code in a member function. Of course, the member function must not be called.<\/p>\n\n\/\/ numberImplicitExplicit.cpp<\/span>\n\n#include <cmath><\/span>\n#include <string><\/span>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nstruct<\/span> Number {\n\tint<\/span> absValue() {\n return<\/span> std::<\/span>abs(val);\n }\n T val{};\n};\n\n\/\/ template class Number<std::string>; \/\/ (2)<\/span>\n\/\/ template int Number<std::string>::absValue(); \/\/ (3)<\/span>\n\nint<\/span> main<\/span>() {\n \n Number<<\/span>std::<\/span>string><\/span> numb;\n \/\/ numb.absValue(); \/\/ (1)<\/span>\n \n}\n<\/pre>\n<\/div>\nnumb.absValue()<\/code> (line 1), you get what you may expect. A compile-time error message essentially says that the is no overload std::abs<\/code> for std::string<\/code> available. Here are the first two lines from the verbose error message:<\/p>\n![\"numberImplicitExplicit\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/numberImplicitExplicit.png\")
<\/p>\ntemplate\u00a0class\u00a0Number<std::string><\/code>) and explicitly instantiated the class template Number<\/code> or you enable line (3) (template\u00a0int\u00a0Number<std::string>::absValue(<\/code>)) and explicitly instantiated the member function absValue<\/code> for std::string<\/code>, you get a compile-time error. This compile-time error is equivalent to the compiler error invoking the member function absValue in line (1) (numb.absValue()<\/code>). Once more, here are the first two lines of the error messages after enabling line (2) or line (3).<\/p>\n\n
![\"numberImplicitExplicit2\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/numberImplicitExplicit2.png\")
<\/p>\n\n
![\"numberImplicitExplicit3\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/numberImplicitExplicit3.png\")
<\/p>\nA Personal Note:<\/h3>\n
Variadic Templates<\/h2>\n
\ntemplate<\/span> <<\/span>typename<\/span> ... Args><\/span>\nvoid<\/span> variadicTemplate(Args ... args) { \n . . . . \/\/ four dots<\/span>\n}\n<\/pre>\n<\/div>\n...<\/code>) makes Args<\/code> or args<\/code> a so-called parameter pack. Precisely, Args<\/code> it 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>\n\ntemplate<\/span> <<\/span>typename<\/span>... Types><\/span> \/\/ (1)<\/span>\nclass<\/span> tuple<\/span>; \n\ntemplate<\/span> <<\/span>typename<\/span> Callable, typename<\/span>... Args ><\/span> \/\/ (2)<\/span>\nexplicit<\/span> thread<\/span>(Callable&&<\/span> f, Args&&<\/span>... args);\t\n\ntemplate<\/span> <<\/span>typename<\/span> Lockable1, typename<\/span> Lockable2, typename<\/span>... LockableN><\/span> \/\/ (3)<\/span>\nvoid<\/span> lock(Lockable1&<\/span> lock1, Lockable2&<\/span> lock2, LockableN&<\/span>... lockn);\n\nsizeof<\/span>...(ParameterPack); \/\/ (4)<\/span>\n<\/pre>\n<\/div>\n\n
std::tuple<\/code> accepts an arbitrary number of different types.<\/li>\nstd::thread<\/code> allows it to invoke a callable with an arbitrary number of arguments. The argument can have different types. You can invoke a callable, such as a function, function object, or lambda expression. The function std::thread<\/code> takes its callable and its arguments by universal reference. If you need more detail: I already wrote about template argument deduction and universal references in my post “Template Arguments<\/a>“.<\/li>\nstd::lock<\/code> It can lock an arbitrary number of lockable types in an atomic step. Locking one lockable type in an atomic step is trivial. Consequently, std::lock<\/code> requires at least two arguments. Lockable<\/code> is named requirement. Types supporting Lockable<\/code> must have the member functions lock<\/code>, unlock<\/code>, and try_lock<\/code>.<\/li>\n sizeof ...<\/code> – operator returns the number of elements in the ParameterPack<\/code>.
\n<\/a><\/li>\n<\/ol>\n sizeof...<\/code>-operator seems special because the ParameterPack is used in the core language. Let me write a few words about it.<\/p>\nsizeof..<\/code>.-Operator<\/h3>\nsizeof<\/code> …-operator can be used to determine how many elements a parameter pack contains directly. The elements are not evaluated.<\/p>\n\n\/\/ printSize.cpp<\/span>\n\n#include <iostream><\/span>\n\nusing<\/span> namespace<\/span> std::<\/span>literals;\n\ntemplate<\/span> <<\/span>typename<\/span> ... Args><\/span>\nvoid<\/span> printSize(Args&&<\/span> ... args){\n std::<\/span>cout <<<\/span> sizeof<\/span>...(Args) <<<\/span> ' '<\/span>; \/\/ (1)<\/span>\n std::<\/span>cout <<<\/span> sizeof<\/span>...(args) <<<\/span> '\\n'<\/span>; \/\/ (2)<\/span>\n}\n\nint<\/span> main() {\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n printSize(); \/\/ (3)<\/span>\n printSize(\"C string\"<\/span>, \"C++ string\"<\/span>s, 2011<\/span>, true<\/span>); \/\/ (4)<\/span>\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\nsizeof<\/code>..-operator allows it to determine the size of the template parameter pack (1) and the function parameter pack (2) at compile time. I apply it to an empty parameter pack (3) and a parameter pack containing four elements. The first element is a C-string and the second a C++ string. To use the C++-string literal, I have to include the namespace std::literals<\/code> (5). C++14 supports C++ string literals.<\/p>\n![\"printSize\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/08\/printSize.png\")
<\/p>\nWhat’s next?<\/h2>\n