Templates — function templates, class templates

WHY do templates exist?

Without templates you have three bad options:

1. Copy-paste per type → duplicated code, bugs fixed in one copy not the others.
2. void* + casts (the old C way) → loses type safety, you can mix up types silently.
3. Macros (#define MAX(a,b)) → no type checking, ugly double-evaluation bugs.

Templates give you generic code that is still fully type-checked at compile time, with zero runtime overhead (the generated code is as fast as hand-written code).

Function Templates

HOW to write one — derive it from a concrete function

Start with a concrete version:

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

Why generalize? The body never mentions int behaviour — it only needs > and copy. So replace the type int with a placeholder name T:

template<typename T>          // T is a type parameter
T maximum(T a, T b) {         // works for ANY T that supports >
    return (a > b) ? a : b;
}

WHAT the compiler does (instantiation)

maximum(3, 7);        // T deduced as int    -> generates int maximum(int,int)
maximum(2.5, 1.1);    // T deduced as double -> generates double maximum(double,double)
maximum<char>('a','z'); // T explicitly char

Why this step? The compiler looks at the arguments, deduces T, then generates code. Nothing exists until you call it — an unused template generates no machine code at all.

Class Templates

HOW — build a tiny generic Box

template<typename T>
class Box {
    T value;                       // member of the parameter type
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

Why <T> everywhere a Box is named? Unlike functions, class templates usually cannot deduce their type from a constructor (pre-C++17), so you must say the type:

Box<int> bi(42);        // a concrete class Box<int> is generated
Box<string> bs("hi");   // a separate class Box<string> is generated

Box<int> and Box<string> are completely different types — they share no code at runtime.

Non-type template parameters & default args

A template parameter can be a compile-time value, not just a type:

template<typename T, int N>      // N is a non-type parameter
class Array {
    T data[N];                   // size known at compile time -> stack-allocated
public:
    int size() const { return N; }
};
Array<double, 5> a;              // array of 5 doubles, N baked in

Why useful? N is known at compile time → no heap, bounds can be checked, fully inlined.

Default template arguments work too: template<typename T = int> class C {...}; → C<> x;.

Template Specialization (steel-manning "one size fits all")

Sometimes the generic version is wrong for one type. Specialization lets you override it:

template<typename T>
class Printer { public: void print(T x){ cout << x; } };
 
template<>                          // full specialization for bool
class Printer<bool> {
public:
    void print(bool b){ cout << (b ? "true" : "false"); }
};

Why? The generic cout << b prints 1/0; for bool we want words. The compiler picks the most specialized match.

Flashcards

Connections

• Generic Programming — templates are C++'s mechanism for it.
• STL Containers — vector, map, pair are all class templates.
• Function Overloading — templates vs overloads; overload resolution picks between them.
• Macros vs Templates — why templates are type-safe and macros are not.
• Compile-time vs Runtime — instantiation happens at compile time → zero runtime cost.
• Type Deduction (auto) — auto reuses the same deduction rules as function templates.
• Template Specialization — overriding the generic blueprint for specific types.

Concept Map

Hinglish (regional understanding)