C++

Templates

Without templates, writing a function that finds the maximum of two values means writing it once per type — maxInt, maxFloat, maxDouble — identical logic, copy-pasted. A template lets you write the logic exactly once, generic over the type, and have the compiler generate the type-specific version automatically wherever it's actually used.

Function templates

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

int i = maxValue(3, 7);            // T becomes int — no cast, no separate function needed
float f = maxValue(2.5f, 1.1f);     // T becomes float
double d = maxValue(3.14, 2.71);    // T becomes double

template <typename T> declares T as a placeholder type — the compiler figures out what T should be from the arguments each specific call actually uses, with no extra syntax required at the call site.

How the compiler actually handles this

Class templates

Classes can be templated too — this is exactly how generic containers work, previewed here and covered fully in the next chapter, STL Containers & Algorithms:

template <typename T>
class Box {
public:
    Box(T value) : value(value) {}
    T get() { return value; }
private:
    T value;
};

Box<int> intBox(42);
Box<std::string> strBox("hello");   // the SAME Box class, holding a completely different type

Templates vs. C-style generic macros

C has no templates — the closest equivalent is a function-like macro, which is pure text substitution with no type checking at all:

// C: a macro "generic" max — no type safety, evaluates arguments TWICE (see C's Preprocessor gotchas)
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// C++: a real template — type-checked, each argument evaluated exactly once
template <typename T>
T maxValue(T a, T b) { return (a > b) ? a : b; }

A template is genuinely type-checked by the compiler and behaves like a normal function in every way that matters (arguments evaluated once, real scoping) — strictly safer than the macro equivalent, not just more convenient syntax.

Real-world applications

• The entire STL — every standard container (vector, map) and algorithm (sort, find) is a template, generic over whatever type you actually store — the subject of the next chapter.
• Generic math/utility libraries — a templated clamp(value, min, max) function working identically across int, float, and any other comparable type.
• Type-safe generic data structures — a templated ring buffer or fixed-size queue, reused across a firmware codebase for any element type without duplicating the logic per type.

Gotchas