Template Specialization (C++)

Kajanan introduced this to me, and I learned about it through Eigen.

Template specialization allows you to provide a specific implementation of a template for a particular data type or set of data types.

When is this ever useful?

This is useful when a general template definition does not suffice, or when a specific type requires optimization or a different behavior.

I learned this through ChatGPT.

Resources

• https://en.cppreference.com/w/cpp/language/template_specialization
• https://www.geeksforgeeks.org/template-specialization-c/

Class Template Specialization

First, you define a primary template that will work for most types:

template<typename T>
class MyTemplate {
public:
    void function() {
        // Default implementation for generic types
        std::cout << "Generic implementation for type " << typeid(T).name() << std::endl;
    }
};

Then, you provide an explicit specialization for a certain type

// Specialization for int type
template<>
class MyTemplate<int> {
public:
    void function() {
        // Implementation specific to int
        std::cout << "Specialized implementation for int" << std::endl;
    }
};

Do I need to reimplement the entire class if I do template specialization?

Unfortunately, yes… Yes, for class template specialization in C++, you need to redefine the entire class for the specialized type. Umm, unless you do CRTP? StackOverflow thread

Function Template Specialization

Similarly, function templates can also be specialized.

The primary template:

template<typename T>
void myFunction(T value) {
    std::cout << "Generic function for type " << typeid(T).name() << std::endl;
}

Specialized template

// Specialization for int
template<>
void myFunction(int value) {
    std::cout << "Specialized function for int" << std::endl;
}

Then, this is what happens

int main() {
    MyTemplate<double> myDouble;  // Uses primary template
    MyTemplate<int> myInt;        // Uses specialized template for int
    MyTemplate<int*> myIntPtr;    // Uses partial specialized template for int pointer
 
    myDouble.function();          // Calls generic implementation
    myInt.function();             // Calls specialized implementation for int
    myIntPtr.function();          // Calls specialized implementation for pointer
 
    myFunction(10);               // Calls specialized function for int
    myFunction(10.5);             // Calls generic function
}