Fixed-Parameter Templates

Suppose you want one piece of code that works whether a caller passes one value, five values, or none at all. A template that always expects the same fixed list of parameters cannot do this without help. Variadic templates, sometimes just called variadics, solve the problem by accepting a varying number of arguments. That flexibility is the reason to use them, but it also creates a cost that you must understand before using them well.

This article focuses on that cost. The source describes the situation as two-sided. The strength of a variadic template is that it can accept any arguments you care to give it. The weakness is that checking the types of its interface can be a possibly elaborate template program. Keep both halves of that statement in mind as you read, because the rest of the article unpacks each one.

A helpful way to picture a variadic template is as a single slot that takes a whole line of arguments, rather than a row of labeled boxes. Each argument in a call occupies a position in that line. The arguments do not need to share a type, and the number of positions is decided by the call, not by the template's declaration.

The diagram uses a made-up call that passes three arguments to show how positions line up. Notice that the template did not list three positions anywhere. The single slot simply received whatever the call supplied, and the three values landed in three positions because the call supplied three values.

The important word in that definition is any. A variadic template is not limited to one specific argument count. Compare this with a template that declares exactly two parameters. That version can only be used with two arguments. The variadic version can be given two arguments, or ten, or none, as long as the arguments are acceptable to it. The source's phrasing points to breadth in the argument list rather than a fixed shape.

Flexibility is easy to grant but harder to verify. When a template has a fixed number of parameters, the question of whether a call is acceptable is fairly contained. The caller supplies the expected number of values, and each one is compared against the expected kind. When a template accepts any number of arguments, the set of acceptable calls is open-ended. The template itself therefore has to describe how its interface should be checked for whatever arguments actually arrive.

This is why the source calls type checking of the interface a possibly elaborate template program. Checking is not a single simple comparison that the template gets for free. Instead, the checking is itself written as template code that can be involved in its own right. The word possibly matters: the source says the checking can be elaborate, not that it always is. Some interfaces will be easy to describe, and others will need considerably more template code to verify.

A fixed template pushes most of its rules into a visible parameter list. A variadic template moves many of those rules into the template's own checking logic. The rules have not disappeared; they have changed location, and that is the weight the designer must carry.

The strength and the weakness of variadic templates come from the same design choice. The openness that lets a caller pass any arguments is the same openness that forces the template to carry more of the burden of deciding what counts as a valid interface. Understanding them together makes the trade-off clearer than treating them as two separate facts.

The source points out that, because of their flexibility, variadic templates are widely used in the standard library. The reasoning is direct. A library is meant to serve many different callers, and those callers will not all want to pass the same number of arguments. A component that accepts any arguments can be reused in more situations than one that fixes its argument count in advance.

The same connection explains why the cost is worth studying. The components that benefit most from flexibility are exactly the ones whose interfaces must be checked carefully. When you read library-style code, recognize that its generality was bought with template logic the designer had to write.