C++ Templates – Basics & Specialization Explained

Introduction – Why Templates Matter in C++

Templates in C++ bring the power of generic programming, allowing functions and classes to operate with any data type. Instead of writing duplicate code for each data type, templates enable you to write a single logic that adapts to all types, increasing code reusability, type safety, and maintainability.

In this guide, you’ll learn:

• What function and class templates are
• How to use and declare them
• Full and partial specialization
• Best practices with real-world examples

What Are C++ Templates?

A template is a blueprint for creating functions or classes that work with different data types. C++ supports:

1. Function Templates
2. Class Templates
3. Template Specialization

Code Examples – With Output

Example 1: Function Template

#include <iostream>
using namespace std;

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    cout << add<int>(5, 3) << endl;       // 8
    cout << add<double>(3.5, 1.2) << endl; // 4.7
    return 0;
}

Output:

8
4.7

Explanation: Same function works for int and double.

Example 2: Class Template

template <typename T>
class Box {
    T value;

public:
    Box(T v) : value(v) {}
    T getValue() { return value; }
};

int main() {
    Box<int> intBox(10);
    Box<string> strBox("Hello");

    cout << intBox.getValue() << endl;
    cout << strBox.getValue() << endl;
}

Output:

10  
Hello

Template Specialization

Full Specialization

template<>
class Box<string> {
public:
    string getValue() { return "Specialized for string"; }
};

Used when you want to handle a specific type differently than the generic template.

Partial Specialization (Advanced)

template <typename T, typename U>
class Pair { /* general case */ };

template <typename T>
class Pair<T, int> { /* specialized case */ };

Partial specialization allows tweaking only part of the template parameters.

Templates Summary Table

Best Practices & Tips

Best Practice: Use templates when behavior is truly independent of data type.

Tip: Use typename or class interchangeably for template parameters (both are valid).

Pitfall: Error messages from template misuse can be complex—use simple examples first when debugging.

Use Cases for Templates

STL Containers: vector<T>, map<K,V>, stack<T>
Math Libraries: Matrix<T>, add<T>(), pow<T>()
Serialization: Generic save/load routines
Algorithms: sort<T>(), find<T>()
Utility Classes: Generic wrappers, resource managers

Summary – Recap & Next Steps

Key Takeaways:

• Templates allow writing generic, type-safe, and reusable code
• Use function or class templates depending on the scenario
• Specialization allows customization for specific data types

Real-World Relevance:
Templates power the Standard Template Library (STL), libraries like Boost, and generic frameworks for high-performance computing.

Next Steps:

• Learn about C++ Exception Handling
• Explore try, catch, throw, and best practices for safe error recovery

FAQ – C++ Templates

Can I overload a template function?
Yes. You can provide a separate overload for specific types or use full specialization.

What’s the difference between typename and class in templates?
They’re interchangeable in template declarations.

Do templates impact performance?
No runtime overhead. All resolution happens at compile time.

What are variadic templates?
Templates that accept a variable number of types (used in tuples, printf-style functions).

Is specialization required for all types?
No. Use it only when behavior differs for a specific type.