[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.4.3)
  if the template parameter pack is a template template parameter; the pattern is the corresponding type-tt-parameter, variable-tt-parameter, or concept-tt-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 annotation-list ([dcl.attr.grammar]); the pattern is an annotation.
(6.11)
In an alignment-specifier ([dcl.align]); the pattern is the alignment-specifier without the ellipsis.
(6.12)
In a capture-list ([expr.prim.lambda.capture]); the pattern is the capture without the ellipsis.
(6.13)
In a sizeof... expression; the pattern is an identifier.
(6.14)
In a pack-index-expression; the pattern is an identifier.
(6.15)
In a pack-index-specifier; the pattern is a typedef-name.
(6.16)
In a fold-expression ([expr.prim.fold]); the pattern is the cast-expression that contains an unexpanded pack.
(6.17)
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 .}_{N, where N is the number of elements in the pack expansion parameters .}}_{2, \dots, E {N, where N is the number of elements in the pack expansion parameters .}_{N, where N is the number of elements in the pack expansion parameters .}}}_{1, E {2, \dots, E {N, where N is the number of elements in the pack expansion parameters .}_{N, where N is the number of elements in the pack expansion parameters .}}_{2, \dots, E {N, where N is the number of elements in the pack expansion parameters .}_{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 .}^{th element .}}_{i is generated by instantiating the pattern and replacing each pack expansion parameter with its {i th element .}^{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
- (9.1.1)
  a typedef-name for a type template parameter pack,
- (9.1.2)
  an id-expression for a constant template parameter pack, or
- (9.1.3)
  a template-name for a template template parameter pack
designating the ${i th corresponding type, constant, or template template argument;}^{th corresponding type, constant, or template 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;}^{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}^{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.}^{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 .}_{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 .}_{K .}

The instantiation of an alignment-specifier with an ellipsis produces

E {1 E {2 \dots E {N .}_{N .}}_{2 \dots E {N .}_{N .}}}_{1 E {2 \dots E {N .}_{N .}}_{2 \dots E {N .}_{N .}}}

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

(14.1)
( (( ${E 1 op {E 2) op \dots) op {E N) for a unary left fold,}_{N) for a unary left fold,}}_{2) op \dots) op {E N) for a unary left fold,}_{N) for a unary left fold,}}}_{1 op {E 2) op \dots) op {E N) for a unary left fold,}_{N) for a unary left fold,}}_{2) op \dots) op {E N) for a unary left fold,}_{N) for a unary left fold,}}}$
(14.2)
( ${E 1 op (\dots op ({E N - 1 op {E N))) for a unary right fold,}_{N))) for a unary right fold,}}_{N - 1 op {E N))) for a unary right fold,}_{N))) for a unary right fold,}}}_{1 op (\dots op ({E N - 1 op {E N))) for a unary right fold,}_{N))) for a unary right fold,}}_{N - 1 op {E N))) for a unary right fold,}_{N))) for a unary right fold,}}}$
(14.3)
( ((E op ${E 1) op {E 2) op \dots) op {E N) for a binary left fold, and}_{N) for a binary left fold, and}}_{2) op \dots) op {E N) for a binary left fold, and}_{N) for a binary left fold, and}}}_{1) op {E 2) op \dots) op {E N) for a binary left fold, and}_{N) for a binary left fold, and}}_{2) op \dots) op {E N) for a binary left fold, and}_{N) for a binary left fold, and}}}$
(14.4)
( ${E 1 op (\dots op ({E N - 1 op ({E N op E))) for a binary right fold .}_{N op E))) for a binary right fold .}}_{N - 1 op ({E N op E))) for a binary right fold .}_{N op E))) for a binary right fold .}}}_{1 op (\dots op ({E N - 1 op ({E N op E))) for a binary right fold .}_{N op E))) for a binary right fold .}}_{N - 1 op ({E N op E))) for a binary right fold .}_{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, 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()

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

E {1, E {2, \dots, E {N .}_{N .}}_{2, \dots, E {N .}_{N .}}}_{1, E {2, \dots, E {N .}_{N .}}_{2, \dots, E {N .}_{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]