Templates in C++

In this lesson: Write generic code with C++ templates — function and class templates — examples with output. In Hindi & English.

What are templates?

Templates let you write code once that works for any type. Instead of writing a separate max for int, double and string, you write one template and the compiler makes each version you need. This is called generic programming.

Function templates

Put template <typename T> before the function and use T as the type:

#include <iostream>
using namespace std;
template <typename T>
T maxOf(T a, T b) {
    return (a > b) ? a : b;
}
int main() {
    cout << maxOf(3, 7) << "\n";        // int
    cout << maxOf(2.5, 1.5) << "\n";    // double
    cout << maxOf('a', 'z') << "\n";    // char
    return 0;
}

The compiler deduces T from the arguments each time.

Multiple type parameters

template <typename A, typename B>
void show(A a, B b) {
    cout << a << " and " << b << "\n";
}
// show(1, "hi");  → int and string

Class templates

A class template makes a whole class generic — perfect for containers:

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() { return value; }
};
int main() {
    Box<int> a(42);
    Box<string> b("hello");
    cout << a.get() << " " << b.get();   // 42 hello
}

Here you specify the type explicitly: Box<int>, Box<string>. For a compact syntax reference, see the templates syntax page.

Templates and the STL

The entire Standard Template Library is built on templates. That is why vector<int>, vector<string> and map<string,int> all come from the same generic code, and algorithms like sort work on any suitable container.

How templates work

A template is not code by itself — it is a recipe. When you use it with a type, the compiler instantiates it, generating a concrete version for that type. Unused templates generate nothing.

Common mistakes

• Forgetting template <typename T> before the definition.
• Expecting the compiler to deduce a class template's type (you often specify it).
• Using a type with the template that lacks a needed operator (e.g. > in maxOf).
• Splitting a template's declaration and definition across files carelessly.

Summary

• Templates write code once that works for any type.
• Function templates deduce the type from the arguments.
• Class templates need the type specified, like Box<int>.
• The compiler instantiates a concrete version per type used.
• The STL is built entirely from templates.