How to explain C++ templates to junior developers?

Question

One could break the question into two: how to read and to write templated code.

It is very easy to say, "it you want an array of doubles, write std::vector<double>", but it won't teach them how the templates work.

Answer 1

There is a saying: "If you can't explain it, you don't understand it."

You can break it down further: How to write code that uses templated code, and how to write code that provides a templated service to others.

The basic explanation is that templates generated code based on a template. That is the source of the term "meta programming". It is programming how programming should be done.

The essential complexity of a vector is not that it is a vector of doubles (or type T), but that it is a vector. The basic structure is the same and templates separate that which is consistent from that which is not.

Further explanation depends on how much of that makes sense to you!

Answer 2

You can tell that a template is a half-written source with parameters to be filled while instatiating the template.

Answer 3

IMHO it is best to explain them as (very) fancy macros. They just work at higher level than C-style text substitution macros.

Answer 4

I found it very instructive to look at duck-typed languages. It doesn't matter, there, what type of argument you give a function, as long as they offer the right interface.

Templates allows to do the same thing: you can take any type, as long as the right interface is present. The additional benefit over duck-typing is, that the interface is checked at compile-time.

Answer 5

Present them as advanced macros. It's a programming language on its own that is executed during compliation.

Answer 6

I would get them to implement something themselves, then experiment with different variations until they understand it. Learning by doing is almost always the better option with programming.

For example, get them to make a template which compares two values and returns the higher one. Then have them see has passing ints or doubles or whatever still allows it to work. Then get them to tweak the the code / copy it and have it return the minimum value. Again, experiment with variations - will the template allow them to pass an int and a double, or will it complain?

From there, you can have them pass in arrays of whatever type (int, double etc), and have it sort the array from highest to lowest, again encouraging experimentation. From there, start to move into templated class definitions, using the same kind of ideas but on a larger scale. This is pretty much how I learnt about templates, ending up with complex array manipulation classes for generic types.

Answer 7

I'd probably try to demonstrate the power of templates, by demonstrating the annoyance of not using them.

A good demonstration would be to write something simple like a stack of doubles (hand-written, not STL), with methods push, pop, and foldTopTwo, which pops off and adds together the top two values in the stack, and pushes the new value back on.

Then tell them to do the same for ints (or whatever, just some different numeric type).

Then show them how, by writing this stack as a template, you can significantly reduce the number of lines of code, and all of that horrible duplication.

Answer 8

When I was teaching myself C++ I used this site a lot. It explains templates in depth and very well. I would recommend having them read that and try implementing something simple.

For a shorter explanation: Templates are frameworks for complicated constructs that act on data without having to know what that data is. Give them some examples of a simple template (like a linked-list) and walk through how the template is used to generate the final class.