Templates

Section: Advanced C++. C++ templates — write generic functions and classes once, reuse them for many types (the foundation of the STL).

#include <iostream>
using namespace std;

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

int main() {
    cout << maximum(10, 20) << "\n";       // T = int
    cout << maximum(2.5, 1.5) << "\n";     // T = double
    cout << maximum('a', 'z') << "\n";     // T = char
    cout << maximum<int>(3, 9) << "\n";    // explicit T
    return 0;
}

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

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

int main() {
    Box<int> a(42);
    Box<string> b("hi");
    cout << a.get() << " " << b.get() << "\n";
    return 0;
}

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

template <typename T, typename U>
class Pair {
public:
    T first;
    U second;
    Pair(T a, U b) : first(a), second(b) {}
};

template <typename T, typename U>
auto addMixed(T a, U b) {
    return a + b; // return type deduced (C++14+)
}

int main() {
    Pair<string, int> p("age", 21);
    cout << p.first << " " << p.second << "\n";
    cout << addMixed(2, 3.5) << "\n";
    return 0;
}

#include <iostream>
using namespace std;

template <typename T, int N>
class FixedArray {
    T data[N];
public:
    int size() const { return N; }
    T& operator[](int i) { return data[i]; }
};

int main() {
    FixedArray<int, 5> a;
    a[0] = 10;
    cout << a.size() << " " << a[0] << "\n"; // 5 10
    return 0;
}

#include <iostream>
using namespace std;

template <typename T>
void printType() {
    cout << "generic\n";
}

template <>
void printType<int>() {
    cout << "int specialization\n";
}

int main() {
    printType<double>(); // generic
    printType<int>();    // int specialization
    return 0;
}

• template before function or class.
• Function templates deduce T; class templates need Class.
• typename and class are the same for type parameters.
• STL = templates everywhere.
• Put template definitions in headers.
• Specialization customizes one type’s behaviour.
• Non-type params: sizes and compile-time constants.
• maximum(2, 3.5) often fails — types must match one T.
• Templates = compile-time / static polymorphism.
• Prefer templates over macros for generics.
• Read the first compiler error in a template blast.
• Cookie-cutter analogy works well in interviews.

1. Write a template min(a,b) and test with int and double.
2. Implement a class template Pair with a print() method.
3. Write mySwap as a function template for two references.
4. Build a simple Stack with push/pop/top using vector.
5. Create FixedArray and print N.
6. Specialize a printType template for int and for string.
7. Show a deduction failure with maximum(1, 2.5) and fix it.
8. Write a template function that prints any array with size N.
9. List five STL templates you already use.
10. Explain in comments why templates live in headers.
11. Add a default template argument to a small class template.
12. Compare templates vs function overloading in a short table.