Defining a "template" for expanding a parameter package, especially in a function call function

Question

I understand that when an ellipsis (...) occurs to the right of a template containing a package of parameters, the template expands once for each parameter in the package. However, although I managed to find separate examples of templates with their extension, I could not find a definition of what the template is. From what I see, spaces do not play any role in the definition of a pattern, but parentheses. For example, in this example:

template<typename ... Ts> void func(Ts) { do_something(validate(Ts)...); } 

the do_something string will be expanded to:

  do_something(validate(var1), validate(var2), validate(var3)) 

if Ts turned out to be three variables. On the contrary:

  do_something(validate(Ts...)); 

will be expanded to:

  do_something(validate(var1, var2, var3)); 

Thus, clear parentheses have something to do with determining where the pattern begins and ends. I also see that there are no gaps in this. But that only brings me so far. I would like to know exactly what the sample is and how it will expand. I tried to search by the C ++ standard, but found too many instances of the “parameter package” to make it effective. Can someone please give me the definition of "template" or a link to the definition or both?

UPDATE: To limit the scope of my question, I would like to focus on the case when the pattern occurs in a function call. I edited the name accordingly. Sorry, I did not make this clear from the start.

Answer 1

The template is defined in the standard in [temp.variadic] / 4 : (via @tc )

A package extension consists of a template and an ellipsis, which creates zero or more instances of the template in the list (described below). The shape of the template depends on the context in which the extension occurs. Package extensions can occur in the following contexts:

• In the function parameter package ([ dcl.fct ]); parameter-declaration template without ellipse.
• In the template options package, which is a package extension ([ temp.param ]:
  • if the template parameter package is parameter-declaration ; parameter-declaration template without ellipse;
  • if the package of template parameters is type-parameter with template-parameter-list ; the template is a corresponding type-parameter without an ellipse.
• In initializer-list ([ dcl.init ]); initializer-clause pattern.
• In base-specifier-list (item [ class.derived ], the template is base-specifier .
• In mem-initializer-list ([ class.base.init ]) for mem-initializer , mem-initializer-id denotes the base class; The template is a mem-initializer .
• In template-argument-list ([ temp.arg ]); template-argument template .
• In dynamic-exception-specification ([ except.spec ]); type-id template.
• In attribute-list ([ dcl.attr.grammar ]); attribute template.
• In alignment-specifier ([ dcl.align ]); alignment-specifier template without ellipse.
• In capture-list ([ expr.prim.lambda ]); capture template.
• In the expression sizeof... ([ expr.sizeof ]); identifier template.
• In fold-expression ([ expr.prim.fold ]); the template is a cast-expression that contains a package of unstretched parameters.

The above quotation from a standard project indicates how much of the grammar described in the links is an extension of the “template”. To understand this, you need to know how the C ++ grammar is described, and the exceptions to how it is used in the most standard text; however, if you have basic BNF knowledge and a little patience, you can fix it. Names are often helpful.

---

However, you can use ... and basically understand it without going almost so deep.

The general rule is simple: you have some bit of C ++ grammar (called a template) that is parsed in the usual way, where a type package is processed as one type, and a package of literals is treated as one literal, Then, at the end, you have ... expander. He then takes all the unexpanded packages into a bit of C ++ grammar immediately before (the template) and extends it.

How it works in every context is different; it is not just a macro extension. The contexts in which it acts ... are listed above; extension effects are listed in the standard at every point where it really is.

In the most common cases ... pattern is an expression, and the expression expands as if each copy were separated (not an operator, , but another "normal"), usually in the context where a list of things is expected (function call, list of initializers etc.).

There are contexts for declaring function parameters (where ... and extends the types of function parameters, and introduces a new package of parameter names), in the parameter lists of the template (where it usually introduces the package), etc.

sizeof... little strange: for sizeof... it counts how many elements are in the packet passed in () . This works differently because ... does not apply to the "structure on the left."

For alignas(X...) we get alignas( X@0 ), alignas( X@1 ), ... (where @0 is my pseudo-code for the first element of the package), because alignas( X@0 , X@1 , ...) invalid C ++ (again @TC in the comments below).

For inheritance, it creates a set of base classes. For mem-initializer-lists, it allows you to pass ctor arguments to a package of base classes. For lambda, this gives you limited packet capture (not full expression capture with the extension of the last one I checked).

The template is expanding. It is important to note that the extended template is not expanded by another template expander: therefore std::array< Ts, sizeof...(Ts) >... is an array of arrays of various types, each of which has several elements determined by how large package yourself. sizeof...(Ts) "counts the extension" Ts in its () , although ... not "correct" because the language defines Ts in () as a template that extends to ...

A template cannot generally be called an expression, because types are not expressions, and some templates are expressions (or at least expand into lists of expressions). And in some cases ... extends the type template into an extended type package (for example, in a throw expression).

The general rule that you treat ... as an expanding object on the left, appropriately in the local context, works for almost everything except sizeof... (which is a magic operator that tells you how many elements are in the parameter package). It will only be in corner cases when it does not create a decent model. And in my experience, in the worst case, this will lead to code that doesn't compile when you think it should; you can explore workarounds in this case. For example, remembering that the bare operator "has no local context", so you cannot do a = std::get<Is>(tup))...; , and in a roundabout way (void)(int[]){0,(a = std::get<Is>(tup)),0)...}; (it may be necessary to introduce tpedef, which is int[] ), where we provide the context (creating an array) for extending the package to work.

C ++ 1z fold expressions are another bizarre spot where ... not applied on the left; here they wanted to have an extension of the binary operator, so the "left" does not have the same meaning as the usual "unary" extension.

Answer 2

A pattern is defined by its association with extension syntax ... Thus, validate(ts) is just a piece of meaningless text. But validate(ts)... makes the validate(ts) part an extension template. So the question is how ... affects the related code.

Typically, the unpacking syntax indicates that the material to the left of ... is a template. With a C ++ 17x expression, this gets a little more complicated. But generally speaking, if you want to know what a template is, find ... and look at the expression immediately to the left of it.

The specific restrictions on what may be in the template completely depend on where the extension occurs and what type of package (type versus non-type, etc.). The template should be what would be the legal code for any context in which it has been extended.