C++ Templates

One recipe, many types

You already saw function overloading: two functions named add, one for int and one for double. The bodies were the same idea copied twice. A template is that idea written once. You name a placeholder type, usually T. At each call, the compiler substitutes the real type and compiles a concrete function.

That substitution happens at compile time. There is no extra decision while the program runs. If the body does not make sense for a type — say you compare two values and that type has no > — g++ reports an error at the call site.

Function template bigger

bigger returns whichever argument compares greater. Prefix the function withtemplate <typename T>. Use T as the parameter type and the return type. The same source covers int and double.

#include <iostream>
using namespace std;

template <typename T>
T bigger(T a, T b) {
  if (a > b) {
    return a;
  }
  return b;
}

int main() {
  cout << bigger(3, 9) << endl;
  cout << bigger(2.5, 2.25) << endl;
  return 0;
}

Output is 9 then 2.5. The first call builds bigger<int>. The second builds bigger<double>. You did not write those names; the compiler did.

The compiler fills in T

Both arguments must agree on T in this version. bigger(3, 9) is fine.bigger(3, 9.1) is not: one argument is int, the other is double, and the template asked for a single T. Cast one side, or write a template that takes two type parameters. This page keeps one T.

You can name the type at the call if you want it written down: bigger<int>(3, 9). Most code lets the compiler infer it from the arguments.

Strings work the same way

string already defines > (lexicographic order). Include<string> and pass two strings. The template body does not change.

#include <iostream>
#include <string>
using namespace std;

template <typename T>
T bigger(T a, T b) {
  if (a > b) {
    return a;
  }
  return b;
}

int main() {
  string left = "kappa";
  string right = "omega";
  cout << bigger(left, right) << endl;
  return 0;
}

Output is omega, because 'o' sorts after 'k'. The algorithm was “return the greater of two values.” The type supplied the comparison.

A tiny class template: Box

A class template is the same placeholder idea on a type. Box<T> holds one value of whatever T you name. Box<int> and Box<string> are two different types. You cannot assign one to the other without converting the contents yourself.

#include <iostream>
#include <string>
using namespace std;

template <typename T>
struct Box {
  T value;
};

int main() {
  Box<int> count;
  count.value = 4;
  Box<string> title;
  title.value = "draft";
  cout << count.value << endl;
  cout << title.value << endl;
  return 0;
}

Output is 4 then draft. vector and map in the next chapters are class templates of this kind, with more members and more rules.

Templates versus overloading

Overload when the bodies differ: one print for an int, another that loops through a list. Use a template when the body is the same and only the type changes. You can mix them later, but you do not need that mix to start.

auto on a variable is a related convenience: the compiler fills in the type of that one name. A template fills in types for a whole function or class you plan to reuse.

The library is built from templates

The Standard Template Library is named that for a reason. vector<int> is a class template. sort is a function template. The next chapter is a map of that library, not a dump of every header.