{"history":[],"article":{"id":"d54bf4f9-7b02-4a62-b73d-9c3041987222","title":"Variadic template","slug":"variadic-template","content":":::summary\n:::\n\n# \nIn [computer programming](https://bliptext.com/articles/computer-programming), **variadic [templates](https://bliptext.com/articles/template-programming)** are [templates](https://bliptext.com/articles/template-programming) that take a variable number of arguments.\nVariadic templates are supported by [C++](https://bliptext.com/articles/c) (since the [C++](https://bliptext.com/articles/c)11 standard), and the [D programming language](https://bliptext.com/articles/d-programming-language).\n\n# C++\nThe variadic template feature of C++ was designed by Douglas Gregor and Jaakko Järvi and was later standardized in C++11.\nPrior to C++11, templates (classes and functions) could only take a fixed number of arguments, which had to be specified when a template was first declared.\nC++11 allows template definitions to take an arbitrary number of arguments of any type.\nThe above template class tuple will take any number of typenames as its template parameters.\nHere, an instance of the above template class is instantiated with three type arguments:\nThe number of arguments can be zero, so tuple<> some_instance_name; will also work.\nIf the variadic template should only allow a positive number of arguments, then this definition can be used:\nVariadic templates may also apply to functions, thus not only providing a type-safe add-on to variadic functions (such as printf), but also allowing a function called with printf-like syntax to process non-trivial objects.\nThe [ellipsis](https://bliptext.com/articles/ellipsis-computer-programming) (...) operator has two roles.\nWhen it occurs to the left of the name of a parameter, it declares a parameter pack.\nUsing the parameter pack, the user can bind zero or more arguments to the variadic template parameters.\nParameter packs can also be used for non-type parameters.\nBy contrast, when the ellipsis operator occurs to the right of a template or function call argument, it unpacks the parameter packs into separate arguments, like the args... in the body of printf below.\nIn practice, the use of an ellipsis operator in the code causes the whole expression that precedes the ellipsis to be repeated for every subsequent argument unpacked from the argument pack, with the expressions separated by commas.\nThe use of variadic templates is often recursive.\nThe variadic parameters themselves are not readily available to the implementation of a function or class.\nTherefore, the typical mechanism for defining something like a C++11 variadic printf replacement would be as follows:\nThis is a recursive template.\nNotice that the variadic template version of my_printf calls itself, or (in the event that args... is empty) calls the base case.\nThere is no simple mechanism to iterate over the values of the variadic template.\nHowever, there are several ways to translate the argument pack into a single argument that can be evaluated separately for each parameter.\nUsually this will rely on [function overloading](https://bliptext.com/articles/function-overloading), or — if the function can simply pick one argument at a time — using a dumb expansion marker:\nwhich can be used as follows:\nwhich will expand to something like:\nThe use of this \"pass\" function is necessary, since the expansion of the argument pack proceeds by separating the function call arguments by commas, which are not equivalent to the comma operator.\nTherefore, some_function(args)...; will never work.\nMoreover, the solution above will only work when the return type of some_function is not void.\nFurthermore, the some_function calls will be executed in an unspecified order, because the order of evaluation of function arguments is undefined.\nTo avoid the unspecified order, brace-enclosed initializer lists can be used, which guarantee strict left-to-right order of evaluation.\nAn initializer list requires a non-void return type, but the comma operator can be used to yield 1 for each expansion element.\nInstead of executing a function, a lambda expression may be specified and executed in place, which allows executing arbitrary sequences of statements in-place.\npass{([&]{ std::cout << args << std::endl; }, 1)...};\nHowever, in this particular example, a lambda function is not necessary.\nA more ordinary expression can be used instead:\npass{(std::cout << args << std::endl, 1)...};\nAnother way is to use overloading with \"termination versions\" of functions.\nThis is more universal, but requires a bit more code and more effort to create.\nOne function receives one argument of some type and the argument pack, whereas the other receives neither.\n(If both had the same list of initial parameters, the call would be ambiguous — a variadic parameter pack alone cannot disambiguate a call.) For example:\nIf args... contains at least one argument, it will redirect to the second version — a parameter pack can be empty, in which case it will simply redirect to the termination version, which will do nothing.\nVariadic templates can also be used in an exception specification, a base class list, or the initialization list of a constructor.\nFor example, a class can specify the following:\nThe unpack operator will replicate the types for the base classes of ClassName, such that this class will be derived from each of the types passed in.\nAlso, the constructor must take a reference to each base class, so as to initialize the base classes of ClassName.\nWith regard to function templates, the variadic parameters can be forwarded.\nWhen combined with universal references (see above), this allows for perfect forwarding:\nThis unpacks the argument list into the constructor of TypeToConstruct.\nThe std::forward(params) syntax perfectly forwards arguments as their proper types, even with regard to rvalue-ness, to the constructor.\nThe unpack operator will propagate the forwarding syntax to each parameter.\nThis particular factory function automatically wraps the allocated memory in a std::shared_ptr for a degree of safety with regard to memory leaks.\nAdditionally, the number of arguments in a template parameter pack can be determined as follows:\nThe expression SomeStruct::size will yield 2, while SomeStruct<>::size will give 0.\n\n# D\n\n## Definition\nThe definition of variadic templates in D is similar to their C++ counterpart:\nLikewise, any argument can precede the argument list:\n\n## Basic usage\nVariadic arguments are very similar to constant array in their usage.\nThey can be iterated upon, accessed by an index, have a length property, and can be [sliced](https://bliptext.com/articles/array-slicing).\nOperations are interpreted at compile time, which means operands can't be runtime value (such as function parameters).\nAnything which is known at compile time can be passed as a variadic arguments.\nIt makes variadic arguments similar to [template alias arguments](https://bliptext.com/articles/undefined), but more powerful, as they also accept basic types (char, short, int...).\nHere is an example that prints the string representation of the variadic parameters.\nStringOf and StringOf2 produce equal results.\nOutputs:\n\n## AliasSeq\nVariadic templates are often used to create a sequence of aliases, named [AliasSeq](https://bliptext.com/articles/undefined).\nThe definition of an AliasSeq is actually very straightforward:\nThis structure allows one to manipulate a list of variadic arguments that will auto-expand.\nThe arguments must either be symbols or values known at compile time.\nThis includes values, types, functions or even non-specialized templates.\nThis allows any operation you would expect:","current_revision":null,"created_by":"kACnuQmH5k9Nr5VNVEpVeg7XpvUmMctD","created_at":"2025-01-26T11:21:30.576Z","updated_at":"2025-01-26T11:21:30.576Z","search_vector":"'templat':2 'variad':1","search_content":" \n \n\n# \nIn [computer programming](https://bliptext.com/articles/computer-programming), **variadic [templates](https://bliptext.com/articles/template-programming)** are [templates](https://bliptext.com/articles/template-programming) that take a variable number of arguments.\nVariadic templates are supported by [C++](https://bliptext.com/articles/c) (since the [C++](https://bliptext.com/articles/c)11 standard), and the [D programming language](https://bliptext.com/articles/d-programming-language).\n\n# C++\nThe variadic template feature of C++ was designed by Douglas Gregor and Jaakko Järvi and was later standardized in C++11.\nPrior to C++11, templates (classes and functions) could only take a fixed number of arguments, which had to be specified when a template was first declared.\nC++11 allows template definitions to take an arbitrary number of arguments of any type.\nThe above template class tuple will take any number of typenames as its template parameters.\nHere, an instance of the above template class is instantiated with three type arguments:\nThe number of arguments can be zero, so tuple<> some_instance_name; will also work.\nIf the variadic template should only allow a positive number of arguments, then this definition can be used:\nVariadic templates may also apply to functions, thus not only providing a type-safe add-on to variadic functions (such as printf), but also allowing a function called with printf-like syntax to process non-trivial objects.\nThe [ellipsis](https://bliptext.com/articles/ellipsis-computer-programming) (...) operator has two roles.\nWhen it occurs to the left of the name of a parameter, it declares a parameter pack.\nUsing the parameter pack, the user can bind zero or more arguments to the variadic template parameters.\nParameter packs can also be used for non-type parameters.\nBy contrast, when the ellipsis operator occurs to the right of a template or function call argument, it unpacks the parameter packs into separate arguments, like the args... in the body of printf below.\nIn practice, the use of an ellipsis operator in the code causes the whole expression that precedes the ellipsis to be repeated for every subsequent argument unpacked from the argument pack, with the expressions separated by commas.\nThe use of variadic templates is often recursive.\nThe variadic parameters themselves are not readily available to the implementation of a function or class.\nTherefore, the typical mechanism for defining something like a C++11 variadic printf replacement would be as follows:\nThis is a recursive template.\nNotice that the variadic template version of my_printf calls itself, or (in the event that args... is empty) calls the base case.\nThere is no simple mechanism to iterate over the values of the variadic template.\nHowever, there are several ways to translate the argument pack into a single argument that can be evaluated separately for each parameter.\nUsually this will rely on [function overloading](https://bliptext.com/articles/function-overloading), or — if the function can simply pick one argument at a time — using a dumb expansion marker:\nwhich can be used as follows:\nwhich will expand to something like:\nThe use of this \"pass\" function is necessary, since the expansion of the argument pack proceeds by separating the function call arguments by commas, which are not equivalent to the comma operator.\nTherefore, some_function(args)...; will never work.\nMoreover, the solution above will only work when the return type of some_function is not void.\nFurthermore, the some_function calls will be executed in an unspecified order, because the order of evaluation of function arguments is undefined.\nTo avoid the unspecified order, brace-enclosed initializer lists can be used, which guarantee strict left-to-right order of evaluation.\nAn initializer list requires a non-void return type, but the comma operator can be used to yield 1 for each expansion element.\nInstead of executing a function, a lambda expression may be specified and executed in place, which allows executing arbitrary sequences of statements in-place.\npass{([&]{ std::cout (params) syntax perfectly forwards arguments as their proper types, even with regard to rvalue-ness, to the constructor.\nThe unpack operator will propagate the forwarding syntax to each parameter.\nThis particular factory function automatically wraps the allocated memory in a std::shared_ptr for a degree of safety with regard to memory leaks.\nAdditionally, the number of arguments in a template parameter pack can be determined as follows:\nThe expression SomeStruct ::size will yield 2, while SomeStruct<>::size will give 0.\n\n# D\n\n## Definition\nThe definition of variadic templates in D is similar to their C++ counterpart:\nLikewise, any argument can precede the argument list:\n\n## Basic usage\nVariadic arguments are very similar to constant array in their usage.\nThey can be iterated upon, accessed by an index, have a length property, and can be [sliced](https://bliptext.com/articles/array-slicing).\nOperations are interpreted at compile time, which means operands can't be runtime value (such as function parameters).\nAnything which is known at compile time can be passed as a variadic arguments.\nIt makes variadic arguments similar to [template alias arguments](https://bliptext.com/articles/undefined), but more powerful, as they also accept basic types (char, short, int...).\nHere is an example that prints the string representation of the variadic parameters.\nStringOf and StringOf2 produce equal results.\nOutputs:\n\n## AliasSeq\nVariadic templates are often used to create a sequence of aliases, named [AliasSeq](https://bliptext.com/articles/undefined).\nThe definition of an AliasSeq is actually very straightforward:\nThis structure allows one to manipulate a list of variadic arguments that will auto-expand.\nThe arguments must either be symbols or values known at compile time.\nThis includes values, types, functions or even non-specialized templates.\nThis allows any operation you would expect:","revisionCount":0},"hasMore":false,"nextCursor":null}

History