Best Practices for Template Programming

Many programs need the same logic over and over again, but applied to different kinds of data. A sorting routine, a stack of items, or a list of values all follow a pattern that does not really depend on whether the values are integers, decimal numbers, or text. Templates are the tool for describing code this way: the pattern is written once, and the specific type of data is supplied later, when the code is used.

This article focuses on three uses that the source highlights. The first is expressing an algorithm that applies to many argument types. The second is expressing a container, so that one definition can hold elements of different types. The third is the effect both of these have on the level of abstraction of code. Each one is traced below, step by step, so you can see what state the code is in at each point.

Before reading on, think about a routine that finds the largest of several values. Suppose you need it for integers, for decimal numbers, and for text. Consider how much of the code you would have to write if you did not use templates.

The key idea is separation. The steps of the algorithm are written in terms of the operation being performed, while the specific type of the data is left open. When the algorithm is needed for a particular argument type, that type is supplied, and the same written logic serves it. The logic does not need to be rewritten for each type; only the type changes.

When one template is used with several argument types, each use produces its own typed version of the pattern. The diagram below shows a single template with an open type slot T. Supplying int, double, and string gives three typed versions, and all three trace back to the same written definition.

The three typed versions behave differently in the sense that each one works with its own element type, but they share the same structure. A change to the template's logic is a change to all of them at once, because they all come from one definition. This is the practical benefit of expressing the algorithm once.

The diagram below separates what a template fixes from what each argument type supplies. The algorithm steps are written once. The operation the steps perform is supplied through use, and the element type is supplied by the argument. Together these produce a result that works for many types.

Without templates, a container for integers and a container for text would each need its own separate definition, even though their structure is the same. Expressing the container as a template keeps the shared structure in one place and leaves the element type to be chosen by whoever uses it. The source gives this as one of its core uses of templates.

Abstraction means working with the idea of something rather than its every concrete detail. Templates raise the level of abstraction of code: the code is written in terms of general roles such as element, operation, or container, and concrete types are attached later. A reader can therefore understand what an algorithm or container does without tracing every specific type it might be used with.

The last item above needs a note. Abstraction does not mean leaving the logic unclear. It means describing the logic in general roles so that the concrete detail can be attached cleanly later. A clearly written template is abstract in this sense; a vague one is simply hard to follow.