[Example 1: template<class ... Types> struct Tuple { }; Tuple<> t0; Tuple<int> t1; Tuple<int, float> t2; Tuple<0> error; — end example]

[Example 2: template<class ... Types> void f(Types ... args); f(); f(1); f(2, 1.0); — end example]

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.

[Example 5: template<class ... Types> void f(Types ... rest); template<class ... Types> void g(Types ... rest) { f(&rest ...); } — end example]

[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; typedef zip<short>::with<unsigned short, unsigned>::type T2; template<class ... Args> void g(Args ... args) { f(const_cast<const Args*>(&args)...); f(5 ...); f(args); f(h(args ...) + args ...); } — end example]

The instantiation of a pack expansion considers items , where N is the number of elements in the pack expansion parameters.

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

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

• if the pack is a template parameter pack, the element is
  • a typedef-name for a type template parameter pack,
  • an id-expression for a constant template parameter pack, or
  • a template-name for a template template parameter pack
  designating the corresponding type, constant, or template template argument;
• if the pack is a function parameter pack, the element is an id-expression designating the function parameter that resulted from instantiation of the function parameter pack declaration;
• if the pack is an init-capture pack, the element is an id-expression designating the variable introduced by the init-capture that resulted from instantiation of the init-capture pack declaration; otherwise
• if the pack is a structured binding pack, the element is an id-expression designating the 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 fold-expression ([expr.prim.fold]) produces:

• ( (( op ) op ⋯) op ) for a unary left fold,
• ( op (⋯ op ( op )) ) for a unary right fold,
• ( (((E op ) op ) op ⋯) op ) for a binary left fold, and
• ( op (⋯ op ( op ( op E))) ) for a binary right fold.

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

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.

[Example 8: template<class... T> struct X : T... { }; template<class... T> void f(T... values) { X<T...> x(values...); } template void f<>(); — end example]