13 Templates [temp]

13.7 Template declarations [temp.decls]

13.7.4 Variadic templates [temp.variadic]

A template parameter pack is a template parameter that accepts zero or more template arguments.

[Example 1: template<class ... Types> struct Tuple { }; Tuple<> t0; // Types contains no arguments Tuple<int> t1; // Types contains one argument: int Tuple<int, float> t2; // Types contains two arguments: int and float Tuple<0> error; // error: 0 is not a type — end example]

A function parameter pack is a function parameter that accepts zero or more function arguments.

[Example 2: template<class ... Types> void f(Types ... args); f(); // args contains no arguments f(1); // args contains one argument: int f(2, 1.0); // args contains two arguments: int and double — end example]

An init-capture pack is a lambda capture that introduces an init-capture for each of the elements in the pack expansion of its initializer.

[Example 3: template <typename... Args> void foo(Args... args) { [...xs=args]{ bar(xs...); // xs is an init-capture pack }; } foo(); // xs contains zero init-captures foo(1); // xs contains one init-capture — end example]

A structured binding pack is an sb-identifier that introduces zero or more structured bindings ([dcl.struct.bind]).

[Example 4: auto foo() -> int(&)[2]; template <class T> void g() { auto [...a] = foo(); // a is a structured binding pack containing two elements auto [b, c, ...d] = foo(); // d is a structured binding pack containing zero elements } — end example]

A pack is a template parameter pack, a function parameter pack, an init-capture pack, or a structured binding pack.

The number of elements of a template parameter pack or a function parameter pack is the number of arguments provided for the parameter pack.

The number of elements of an init-capture pack is the number of elements in the pack expansion of its initializer.

A pack expansion consists of a pattern and an ellipsis, the instantiation of which produces zero or more instantiations of the pattern in a list (described below).

The form of the pattern depends on the context in which the expansion occurs.

Pack expansions can occur in the following contexts:

(6.1)
In a function parameter pack ([dcl.fct]); the pattern is the parameter-declaration without the ellipsis.
(6.2)
In a using-declaration ([namespace.udecl]); the pattern is a using-declarator.
(6.3)
In a friend-type-declaration ([class.mem.general]); the pattern is a friend-type-specifier.
(6.4)
In a template parameter pack that is a pack expansion ([temp.param]):
- (6.4.1)
  if the template parameter pack is a parameter-declaration; the pattern is the parameter-declaration without the ellipsis;
- (6.4.2)
  if the template parameter pack is a type-parameter; the pattern is the corresponding type-parameter without the ellipsis.
(6.5)
In an initializer-list ([dcl.init]); the pattern is an initializer-clause.
(6.6)
In a base-specifier-list ([class.derived]); the pattern is a base-specifier.
(6.7)
In a mem-initializer-list ([class.base.init]) for a mem-initializer whose mem-initializer-id denotes a base class; the pattern is the mem-initializer.
(6.8)
In a template-argument-list ([temp.arg]); the pattern is a template-argument.
(6.9)
In an attribute-list ([dcl.attr.grammar]); the pattern is an attribute.
(6.10)
In an alignment-specifier ([dcl.align]); the pattern is the alignment-specifier without the ellipsis.
(6.11)
In a capture-list ([expr.prim.lambda.capture]); the pattern is the capture without the ellipsis.
(6.12)
In a sizeof... expression; the pattern is an identifier.
(6.13)
In a pack-index-expression; the pattern is an identifier.
(6.14)
In a pack-index-specifier; the pattern is a typedef-name.
(6.15)
In a fold-expression ([expr.prim.fold]); the pattern is the cast-expression that contains an unexpanded pack.
(6.16)
In a fold expanded constraint ([temp.constr.fold]); the pattern is the constraint of that fold expanded constraint.

[Example 5: template<class ... Types> void f(Types ... rest); template<class ... Types> void g(Types ... rest) { f(&rest ...); // “&rest ...'' is a pack expansion; “&rest'' is its pattern } — end example]

For the purpose of determining whether a pack satisfies a rule regarding entities other than packs, the pack is considered to be the entity that would result from an instantiation of the pattern in which it appears.

A pack whose name appears within the pattern of a pack expansion is expanded by that pack expansion.

An appearance of the name of a pack is only expanded by the innermost enclosing pack expansion.

The pattern of a pack expansion shall name one or more packs that are not expanded by a nested pack expansion; such packs are called unexpanded packs in the pattern.

All of the packs expanded by a pack expansion shall have the same number of arguments specified.

An appearance of a name of a pack that is not expanded is ill-formed.

[Example 6: template<typename...> struct Tuple {}; template<typename T1, typename T2> struct Pair {}; template<class ... Args1> struct zip { template<class ... Args2> struct with { typedef Tuple<Pair<Args1, Args2> ... > type; }; }; typedef zip<short, int>::with<unsigned short, unsigned>::type T1; // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>> typedef zip<short>::with<unsigned short, unsigned>::type T2; // error: different number of arguments specified for Args1 and Args2 template<class ... Args> void g(Args ... args) { // OK, Args is expanded by the function parameter pack args f(const_cast<const Args*>(&args)...); // OK, “Args'' and “args'' are expanded f(5 ...); // error: pattern does not contain any packs f(args); // error: pack “args'' is not expanded f(h(args ...) + args ...); // OK, first “args'' expanded within h, // second “args'' expanded within f } — end example]

The instantiation of a pack expansion considers items

E_{1}, E_{2}, \dots, E_{N}

, where N is the number of elements in the pack expansion parameters.

Each

E_{i}

is generated by instantiating the pattern and replacing each pack expansion parameter with its

i^{th}

element.

Such an element, in the context of the instantiation, is interpreted as follows:

(9.1)
if the pack is a template parameter pack, the element is an id-expression (for a non-type template parameter pack), a typedef-name (for a type template parameter pack declared without template), or a template-name (for a type template parameter pack declared with template), designating the $i^{th}$ corresponding type or value template argument;
(9.2)
if the pack is a function parameter pack, the element is an id-expression designating the $i^{th}$ function parameter that resulted from instantiation of the function parameter pack declaration;
(9.3)
if the pack is an init-capture pack, the element is an id-expression designating the variable introduced by the $i^{th}$ init-capture that resulted from instantiation of the init-capture pack declaration; otherwise
(9.4)
if the pack is a structured binding pack, the element is an id-expression designating the $i^{th}$ structured binding in the pack that resulted from the structured binding declaration.

When N is zero, the instantiation of a pack expansion does not alter the syntactic interpretation of the enclosing construct, even in cases where omitting the pack expansion entirely would otherwise be ill-formed or would result in an ambiguity in the grammar.

The instantiation of a sizeof... expression ([expr.sizeof]) produces an integral constant with value N.

When instantiating a pack-index-expression P, let K be the index of P.

The instantiation of P is the id-expression

E_{K}

When instantiating a pack-index-specifier P, let K be the index of P.

The instantiation of P is the typedef-name

E_{K}

The instantiation of an alignment-specifier with an ellipsis produces

E_{1}

E_{2}

…

E_{N}

The instantiation of a fold-expression ([expr.prim.fold]) produces:

(14.1)
( (( $E_{1}$ op $E_{2}$ ) op ⋯) op $E_{N}$ ) for a unary left fold,
(14.2)
( $E_{1}$ op (⋯ op ( $E_{N - 1}$ op $E_{N}$ )) ) for a unary right fold,
(14.3)
( (((E op $E_{1}$ ) op $E_{2}$ ) op ⋯) op $E_{N}$ ) for a binary left fold, and
(14.4)
( $E_{1}$ op (⋯ op ( $E_{N - 1}$ op ( $E_{N}$ op E))) ) for a binary right fold.

In each case, op is the fold-operator.

For a binary fold, E is generated by instantiating the cast-expression that did not contain an unexpanded pack.

[Example 7: template<typename ...Args> bool all(Args ...args) { return (... && args); } bool b = all(true, true, true, false);

Within the instantiation of all, the returned expression expands to ((true && true) && true) && false, which evaluates to false.

— end example]

If N is zero for a unary fold, the value of the expression is shown in Table 20; if the operator is not listed in Table 20, the instantiation is ill-formed.

Table 20: Value of folding empty sequences [tab:temp.fold.empty]

🔗	Operator	Value when pack is empty
🔗	&&	true
🔗	\|\|	false
🔗	,	void()

A fold expanded constraint is not instantiated ([temp.constr.fold]).

The instantiation of any other pack expansion produces a list of elements

E_{1}, E_{2}, \dots, E_{N}

[Note 1:

The variety of list varies with the context: expression-list, base-specifier-list, template-argument-list, etc.

— end note]

When N is zero, the instantiation of the expansion produces an empty list.

[Example 8: template<class... T> struct X : T... { }; template<class... T> void f(T... values) { X<T...> x(values...); } template void f<>(); // OK, X<> has no base classes // x is a variable of type X<> that is value-initialized — end example]