Template Classes in C++ – A Complete Guide

What Are Template Classes in C++?

A template class is a class definition that uses placeholders (called template parameters) for data types. Instead of writing multiple versions of the same class for int, float, or string, you write it once as a template, and the compiler generates the required versions.

For example, you can create a generic container like a stack that works with any data type.

Why Use Template Classes?

The main benefits of C++ template programming are:

1. Reusability – Define once, use for multiple data types.
2. Type Safety – Avoid unsafe conversions, unlike using void* in C.
3. Flexibility – Works for primitive and user-defined types.
4. Easier Maintenance – No code duplication, less redundancy.

Syntax of Template Class in C++

template 
class MyClass {
    T data;
public:
    MyClass(T val) : data(val) {}
    void show() { cout << "Value: " << data << endl; }
};

Here, T is the template parameter, representing a type decided at object creation.

Example of Template Class in C++

#include 
using namespace std;

template 
class Play {
    T val;
public:
    Play(T v) : val(v) {}
    void display() { cout << "Value: " << val << endl; }
};

int main() {
    Play obj1(42);
    Play obj2(3.14);
    Play obj3("Hello C++");

    obj1.display();
    obj2.display();
    obj3.display();
    return 0;
}

Output:

Value: 42
Value: 3.14
Value: Hello C++

Template Class for a Stack – Practical Example

A stack is a LIFO (Last In, First Out) data structure. With template classes in C++, we can build a generic stack that works with any type:

template 
class Stack {
    T arr[100];
    int top;
public:
    Stack() : top(-1) {}
    void push(T val) {
        if (top >= 99) { cout << "Stack Overflow!\n"; return; }
        arr[++top] = val;
    }
    void pop() {
        if (top < 0) { cout << "Stack Underflow!\n"; return; }
        cout << "Popped: " << arr[top--] << endl; } void peek() { if (top >= 0) cout << "Top: " << arr[top] << endl;
        else cout << "Stack is empty!\n";
    }
};

Multiple Template Parameters in C++

template 
class Pair {
    T1 first;
    T2 second;
public:
    Pair(T1 a, T2 b) : first(a), second(b) {}
    void display() {
        cout << "Pair: (" << first << ", " << second << ")" << endl;
    }
};

How Templates Work in C++ – Explained

When you use a C++ class template, the compiler creates a new version of the class for each type you instantiate (e.g., Stack and Stack generate separate classes internally).

Advanced C++ Templates and Constraints

• Template Constraints (C++20) – Restrict which types can be used.
• Partial Specialization – Customize templates for specific types.
• Template Metaprogramming – Perform computations at compile-time.

Best Practices for Template Classes

• Use clear template parameter names (e.g., Key, Value).
• Avoid unnecessary template overuse to reduce code bloat.
• Check STL before writing custom templates (vector, map, stack exist).
• Use constraints for safer generic programming.

Summary – Template Classes in C++

• Template classes in C++ enable reusable and type-safe programming.
• They allow creating generic data structures like stacks, pairs, and containers.
• Modern features like constraints and metaprogramming make them more powerful.

Common Mistakes to Avoid

• Overusing templates → Leads to code size bloat.
• Forgetting STL alternatives → Reinventing the wheel.
• Using unclear parameter names → Confusing for maintainers.

Conclusion

Template classes in C++ form the foundation of generic programming. From building simple containers to advanced metaprogramming, mastering templates ensures you write reusable, type-safe, and scalable code for embedded systems, software engineering, and high-performance applications.