🧰 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.