Templates & Generic Programming

Chapter 1: Function Templates

A function template is a formula for generating type-specific functions. The compiler deduces the template arguments from the function call:

c++
template <typename T>
T mymax(const T &a, const T &b) {
    return a < b ? b : a;
}

mymax(3, 7);          // T deduced as int → mymax<int>
mymax(3.14, 2.72);    // T deduced as double → mymax<double>
mymax(string("hi"), string("bye"));  // T = string

// Explicit template argument when deduction fails
mymax<double>(3, 3.14);  // force T = double

Instantiation

When the compiler sees mymax(3, 7), it instantiates the template: generates a real function mymax<int> with T replaced by int. Each distinct type produces a separate instantiation.

Template Requirements

The compare template uses < on type T. If you instantiate it with a type that doesn't have operator<, you get a compile error (at instantiation time, not definition time). Templates implicitly require certain operations from their type parameters.

Chapter 2: Class Templates

A class template is a blueprint for generating classes. Unlike function templates, the compiler cannot deduce template arguments for class templates — you must specify them explicitly:

c++
template <typename T>
class Blob {
public:
    typedef T value_type;
    Blob() : data(make_shared<vector<T>>()) {}
    Blob(initializer_list<T> il)
        : data(make_shared<vector<T>>(il)) {}

    void push_back(const T &t) { data->push_back(t); }
    void push_back(T &&t) { data->push_back(std::move(t)); }

    T& back() { return data->back(); }
    T& operator[](size_t i) { return (*data)[i]; }
    size_t size() const { return data->size(); }
private:
    shared_ptr<vector<T>> data;
};

Blob<int> ia = {0, 1, 2, 3};
Blob<string> sa = {"hi", "bye"};

Member Functions

Member functions of class templates are themselves function templates. They are only instantiated when used — if you never call push_back, the compiler never generates code for it. This means a class template can be instantiated with a type that supports some but not all operations.

Template Type Aliases

c++
// C++11: template aliases with using
template <typename T>
using twin = pair<T, T>;

twin<int> p;       // pair<int, int>
twin<string> s;    // pair<string, string>

Chapter 3: Template Parameters

Template parameters can be types (typename T) or values (int N). They can also have defaults:

c++
// Type parameter
template <typename T>
void print(const T &val) { cout << val; }

// Non-type parameter (must be a constant expression)
template <unsigned N, unsigned M>
int compare(const char (&a)[N], const char (&b)[M]) {
    return strcmp(a, b);
}
compare("hi", "world");  // N=3, M=6 (includes null terminator)

// Default template arguments
template <typename T, typename F = less<T>>
int compare(const T &a, const T &b, F f = F()) {
    if (f(a, b)) return -1;
    if (f(b, a)) return 1;
    return 0;
}

Member Templates

A class (template or not) can have member functions that are themselves templates:

c++
template <typename T>
class Blob {
    // Member template: construct from any iterator range
    template <typename It>
    Blob(It b, It e) : data(make_shared<vector<T>>(b, e)) {}
};

Chapter 4: Type Deduction

When calling a function template, the compiler deduces the template arguments from the function arguments. The deduction rules are precise:

Trailing Return Types

When the return type depends on the template parameters, use a trailing return type with decltype:

c++
template <typename It>
auto fcn(It beg, It end) -> decltype(*beg) {
    return *beg;  // returns a reference to the element
}

Chapter 5: std::move & Perfect Forwarding

Two of the most important utilities in modern C++ — std::move and std::forward — are implemented using template mechanics.

How std::move Works

c++
// Simplified std::move implementation
template <typename T>
typename remove_reference<T>::type&& move(T&& t) {
    return static_cast<typename remove_reference<T>::type&&>(t);
}

It's just a cast. std::move doesn't move anything — it casts its argument to an rvalue reference, which allows the move constructor/assignment to be called.

Perfect Forwarding

Forwarding means passing arguments to another function preserving their lvalue/rvalue nature and const/non-const qualifiers:

c++
template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2) {
    f(std::forward<T2>(t2), std::forward<T1>(t1));
}
// If t1 was an lvalue, forward preserves it as lvalue
// If t1 was an rvalue, forward preserves it as rvalue

Chapter 6: Variadic Templates

A variadic template takes a variable number of template parameters, called a parameter pack:

c++
// Base case: one argument
template <typename T>
ostream& print(ostream &os, const T &t) {
    return os << t;
}

// Recursive case: peel off first, recurse on rest
template <typename T, typename... Args>
ostream& print(ostream &os, const T &t, const Args&... rest) {
    os << t << ", ";
    return print(os, rest...);  // expand pack: recurse
}

print(cout, 42, "hello", 3.14);
// → print(cout, 42, "hello", 3.14)  T=int,    Args={char*,double}
// → print(cout, "hello", 3.14)       T=char*,  Args={double}
// → print(cout, 3.14)                T=double, base case

sizeof... Operator

c++
template <typename... Args>
void foo(Args... args) {
    cout << sizeof...(Args) << endl;  // number of type params
    cout << sizeof...(args) << endl;  // number of function args
}

Forwarding Parameter Packs

Combine variadic templates with perfect forwarding for maximum generality. This is how make_shared and emplace_back work:

c++
template <typename... Args>
void emplace_back(Args&&... args) {
    // forwards each argument preserving lvalue/rvalue
    alloc.construct(first_free++, std::forward<Args>(args)...);
}

Chapter 7: Template Specialization

Sometimes the generic template doesn't work (or isn't optimal) for a specific type. A specialization provides a custom implementation for that type:

c++
// Primary template
template <typename T>
int compare(const T &a, const T &b) {
    if (a < b) return -1;
    if (b < a) return 1;
    return 0;
}

// Full specialization for const char*
template <>  // empty angle brackets = specialization
int compare(const char* const &a, const char* const &b) {
    return strcmp(a, b);  // compare strings, not pointer values
}

Class Template Partial Specialization

Class templates (but not function templates) can be partially specialized — specialized for a subset of template arguments:

c++
// Primary template
template <typename T> struct remove_reference       { using type = T; };

// Partial specialization for lvalue references
template <typename T> struct remove_reference<T&>   { using type = T; };

// Partial specialization for rvalue references
template <typename T> struct remove_reference<T&&>  { using type = T; };

Chapter 8: Instantiation Simulator

Let's visualize how the compiler processes templates. When you write a template call, the compiler substitutes types and generates real code. Each unique type combination produces a separate instantiation.

Chapter 9: Beyond — Connections

Templates are the foundation of the entire C++ standard library. vector, shared_ptr, sort, find, make_shared — all are templates. Understanding templates is understanding how C++ works at its core.

The Complete Series

You've now covered the essential chapters of C++ Primer — from basic types through templates. Return to the chapter index to review any chapter.