Template Specialization in Separate Files

Handling template specialization with separate implementation files can be tricky, but it's doable with the right approach. Let's walk through the process step by step.

Declaration in Header File

First, declare both the primary template and its specializations in the header file:

1// MyTemplate.h
2#pragma once
3
4template <typename T>
5class MyTemplate {
6public:
7    void foo();
8};
9
10// Declare specialization
11template <>
12class MyTemplate<int> {
13public:
14    void foo();
15};

Implementation in Separate File

Next, implement both the primary template and specializations in a separate .cpp file:

1// MyTemplate.cpp
2#include "MyTemplate.h"
3#include <iostream>
4
5template <typename T>
6void MyTemplate<T>::foo() {
7    std::cout << "General template\n";
8}
9
10// Implement specialization
11void MyTemplate<int>::foo() {
12    std::cout << "Specialized for int\n";
13}
14
15// Explicit instantiation
16template class MyTemplate<double>;

Note the explicit instantiation at the end. This is crucial for making the template available to other translation units.

Usage

Now you can use your template in other files:

1// main.cpp
2#include "MyTemplate.h"
3
4int main() {
5  MyTemplate<double> d;
6  d.foo();  // Outputs: "General template"
7
8  MyTemplate<int> i;
9  i.foo();  // Outputs: "Specialized for int"
10}

1General template
2Specialized for int

Potential Pitfalls

1. Forgetting explicit instantiation can lead to linker errors.
2. If you add new specializations, you need to update both the header and implementation files.

Best Practices

• Keep all specializations in the same header and implementation files as the primary template for better organization.
• Use explicit instantiation for commonly used types to reduce compilation times in large projects.
• Consider using export declarations (if supported by your compiler) for more complex scenarios.

Remember, while this approach works, it's often simpler to keep template definitions in header files, especially for smaller projects. Only move to separate implementation files if you have a specific need, such as reducing compilation times in large projects.