Template Specialization

Video: Generics in C++ 4 - Template Functions Full and Partial Specialization | Modern Cpp Series Ep. 74

Template specialization allows you to provide custom implementations for specific types or type combinations. Understanding when and how to use specialization versus overloading is crucial for writing efficient, maintainable template code.

Overloading vs Templates

Function Overloading

Function overloading creates multiple functions with the same name but different parameter types:

// Overloaded functions
int min(int a, int b) { return (a < b) ? a : b; }
double min(double a, double b) { return (a < b) ? a : b; }
const char* min(const char* a, const char* b) { 
    return (strcmp(a, b) < 0) ? a : b; 
}

Key points:

• Each overload is a separate function
• Compiler chooses the best match based on argument types
• No template instantiation overhead
• Clear, predictable behavior

Template Specialization

Template specialization provides custom implementations for specific types:

template<typename T>
T min(T a, T b) {
    return (a < b) ? a : b;
}

// Full specialization for const char*
template<>
const char* min<const char*>(const char* a, const char* b) {
    return (strcmp(a, b) < 0) ? a : b;
}

Key points:

• Specialized version is used for exact type match
• Base template handles all other types
• Can lead to unexpected behavior if not careful

When to Use Each Approach

Prefer Overloading When:

1. Different behavior for different types: If the logic differs significantly
2. Performance critical code: Avoid template instantiation overhead
3. Simple type differences: Basic overloads are clearer
4. Avoiding template bloat: Each overload is a separate function

Use Specialization When:

1. Customizing template behavior: Modifying existing template logic
2. Type-specific optimizations: Special cases for performance
3. Extending template functionality: Adding type-specific features
4. Maintaining template interface: Keeping the same function signature

Full Specialization

Full specialization provides a complete implementation for a specific type:

template<typename T>
class Box {
    T data;
public:
    Box(const T& value) : data(value) {}
    T get() const { return data; }
    void set(const T& value) { data = value; }
};

// Full specialization for pointers
template<>
class Box<int*> {
    int* data;
public:
    Box(int* value) : data(value) {}
    int* get() const { return data; }
    void set(int* value) { data = value; }

    // Pointer-specific functionality
    int getValue() const { return data ? *data : 0; }
    void setValue(int value) { if (data) *data = value; }
};

Partial Specialization

Partial specialization allows you to specialize for a subset of template parameters:

template<typename T, typename U>
class Pair {
    T first;
    U second;
public:
    Pair(const T& f, const U& s) : first(f), second(s) {}
    T getFirst() const { return first; }
    U getSecond() const { return second; }
};

// Partial specialization: second type is pointer
template<typename T>
class Pair<T, T*> {
    T first;
    T* second;
public:
    Pair(const T& f, T* s) : first(f), second(s) {}
    T getFirst() const { return first; }
    T* getSecond() const { return second; }

    // Pointer-specific functionality
    T getSecondValue() const { return second ? *second : T{}; }
};

// Partial specialization: both types are pointers
template<typename T>
class Pair<T*, T*> {
    T* first;
    T* second;
public:
    Pair(T* f, T* s) : first(f), second(s) {}
    T* getFirst() const { return first; }
    T* getSecond() const { return second; }

    // Pointer-specific functionality
    T getFirstValue() const { return first ? *first : T{}; }
    T getSecondValue() const { return second ? *second : T{}; }
};

Specialization Placement Rules

Header vs Source Files

Template definitions must be visible at the point of instantiation, which means:

1. Primary templates: Usually defined in headers
2. Specializations: Can be in headers or source files
3. Explicit instantiation: Can be in source files

// header.h
template<typename T>
class Container {
    T data;
public:
    Container(const T& value);
    T get() const;
};

// Explicit instantiation in source file
template class Container<int>;
template class Container<double>;

ODR (One Definition Rule) Considerations

Warning: Specializations in multiple translation units can cause ODR violations:

// file1.cpp
template<>
class Container<std::string> {
    // Custom implementation
};

// file2.cpp  
template<>
class Container<std::string> {
    // Different implementation - ODR violation!
};

Solution: Define specializations in headers or use explicit instantiation.

Common Pitfalls

1. Function Template Specialization

Avoid specializing function templates - prefer overloading:

// Don't do this - can lead to unexpected behavior
template<typename T>
void process(T value) { /* generic implementation */ }

template<>
void process<int>(int value) { /* int-specific */ }

// Do this instead - clearer and more predictable
template<typename T>
void process(T value) { /* generic implementation */ }

void process(int value) { /* int-specific overload */ }

2. Partial Specialization of Functions

Function templates cannot be partially specialized:

// This won't compile
template<typename T, typename U>
void func(T a, U b) { /* implementation */ }

template<typename T>
void func<T, int>(T a, int b) { /* partial specialization - ERROR! */ }

// Use overloading instead
template<typename T, typename U>
void func(T a, U b) { /* implementation */ }

template<typename T>
void func(T a, int b) { /* overload for second parameter */ }

3. Specialization vs Overload Resolution

Specialization doesn't participate in overload resolution:

template<typename T>
void func(T value) { std::cout << "Template\n"; }

template<>
void func<int>(int value) { std::cout << "Specialization\n"; }

void func(int value) { std::cout << "Overload\n"; }

int main() {
    func(42);  // Calls overload, not specialization!
}

Best Practices

1. Prefer overloading for functions: More predictable behavior
2. Use specialization for classes: Better control over class behavior
3. Keep specializations in headers: Avoid ODR violations
4. Document specialization behavior: Make it clear when specializations are used
5. Test thoroughly: Specializations can have subtle interactions

Your Task

Implement a partial specialization for Box<T*> that overrides the get() method to return dereferenced values and the set() method to set the value of the dereferenced pointer to reference:

template<typename T>
class Box {
    T data;
public:
    Box(const T& value) {
        data = value;
    }
    T get() const { return data; }
    void set(const T& value) { data = value; }
};

// TODO: Partial specialization for Box<T*>
// Override the get() method to return T instead of T*
// This means Box<int*> should return int, not int*

Your implementation should demonstrate how partial specialization can change the behavior of specific methods while maintaining the same interface.

Implement partial specialization for Box that overrides the get() method to return dereferenced values.

// Base Box template class - already implemented
template<typename T>
class Box {
    T data;
public:
    Box(const T& value) {
        data = value;
    }
    T get() const { return data; }
    void set(const T& value) { data = value; }
};

// TODO: Implement partial specialization for Box<T*>
// The specialization should specialize the get() method to return the dereferenced value
// This means Box<int*> should return int& instead of int*
// Same for setting the value, you should set the value of the dereferenced pointer to reference: void 
set(int& value)