C++ Templates: Generic Functions and Classes Explained

Write It Once, Use It for Every Type

On the previous page you sorted a vector<int> with std::sort. But std::sort also sorts a vector<string>, a vector<double>, or an array of your own structs - without anyone writing a separate sort for each. That is not magic and it is not overloading. It is a template: a single piece of code the compiler reuses for whatever type you hand it.

Without templates you'd be stuck copy-pasting the same logic for every type. Here's the same maximum function written three times, which is exactly the duplication templates exist to kill:

int    maximum(int a, int b)       { return a > b ? a : b; }
double maximum(double a, double b) { return a > b ? a : b; }
string maximum(string a, string b) { return a > b ? a : b; }

The bodies are identical. Only the types differ. A template lets you say "this works for any type T" and write it once.

Function Templates

You turn a function into a template by adding template <typename T> in front of it and using T wherever a concrete type would normally go.

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

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << maximum(3, 7) << "\n";          // 7   (T = int)
    cout << maximum(2.5, 1.1) << "\n";      // 2.5 (T = double)
    cout << maximum(string("apple"),
                    string("banana")) << "\n"; // banana (T = string)
    return 0;
}

Notice you never wrote maximum<int> or maximum<double>. The compiler looks at the arguments and figures out what T should be - that's template argument deduction. Each distinct type you call it with causes the compiler to instantiate (generate) a separate concrete function behind the scenes.

You can spell out the type explicitly when deduction can't help, using angle brackets:

#include <iostream>
using namespace std;

template <typename T>
T zero() {            // nothing to deduce from - no arguments
    return T{};
}

int main() {
    cout << zero<int>() << "\n";     // 0
    cout << zero<double>() << "\n";  // 0
    return 0;
}

A common gotcha lurks in deduction. Because T must be a single type, mixing argument types breaks it:

maximum(3, 7.5);   // ERROR: is T int or double? The compiler refuses to guess.

You can fix this by being explicit - maximum<double>(3, 7.5) - or by giving each parameter its own type parameter, which we'll do next.

Multiple Type Parameters

A template isn't limited to one type. List as many as you need, separated by commas. This is how you write a function whose parameters can be different types:

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

template <typename A, typename B>
void printPair(A first, B second) {
    cout << first << " -> " << second << "\n";
}

int main() {
    printPair(1, "one");        // A = int, B = const char*
    printPair(3.14, true);      // A = double, B = bool
    printPair("pi", 3.14159);   // A = const char*, B = double
    return 0;
}

When the return type depends on the parameters, let the compiler work it out with auto (C++14 and later), which pairs naturally with templates:

#include <iostream>
using namespace std;

template <typename A, typename B>
auto add(A a, B b) {
    return a + b;   // return type deduced from a + b
}

int main() {
    cout << add(2, 3) << "\n";     // 5    (int + int)
    cout << add(2, 3.5) << "\n";   // 5.5  (int + double -> double)
    return 0;
}

Class Templates

Templates aren't just for functions - whole classes can be templated. This is exactly how the standard containers work: vector<int>, the key-value map, and pair<A, B> are all class templates. You write the data structure once and it stores whatever type you parameterize it with.

Here's a tiny generic Box that holds one value of any type:

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

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<string> wordBox("hello");

    cout << intBox.get() << "\n";   // 42
    cout << wordBox.get() << "\n";  // hello

    intBox.set(100);
    cout << intBox.get() << "\n";   // 100
    return 0;
}

The key difference from function templates: with a class template you usually have to supply the type in angle brackets - Box<int> - because there are no constructor arguments to deduce from in older standards. (C++17 added class template argument deduction, so Box b(42); works too, but being explicit is always safe and reads clearly.)

The Errors Will Be Enormous - Here's Why

This is the part that trips everyone up, so it's worth saying plainly. A template is only fully checked when it is instantiated with a real type. You can write a template that uses <, and it compiles fine on its own - the error only appears the moment you instantiate it with a type that has no <.

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;   // requires that T supports >
}

struct Point { int x, y; };

// maximum(Point{1,2}, Point{3,4});
// ERROR: no operator > for Point. The message names Point AND
// quotes this whole function, often spanning many lines.

Because the compiler substitutes the full type into the template and reports failures from inside the generated code, a single mistake can produce a wall of output mentioning library internals. Two survival tips:

• Read the first error, not the last. Later errors are usually fallout from the first.
• Scan the message for your own type name (here, Point). That tells you which instantiation went wrong.

The real fix is to make sure your type supports whatever the template needs - for maximum, that means overloading operator> for Point, which is a topic for a later page. Modern C++20 concepts can move these errors earlier and make them readable, but the substitution model underneath is the same.

Next: Classes

You just built a Box class template - a class with private data, a constructor, and member functions - while focusing on the templating. The next page slows down and teaches classes properly: how to bundle data with the functions that operate on it, what public and private really control, and how member functions access the object's own state. Templates and classes combine constantly in real C++, so a solid grip on classes makes generic code far easier to write.