Extern Templates with Separate Files

Using extern templates with separate implementation files can be a powerful technique for reducing compile times in large C++ projects. Let's explore the implications and how to use this feature effectively.

Introduced in C++11, extern templates allow you to declare that a template instantiation exists somewhere else in the program, preventing the compiler from generating code for that instantiation in the current translation unit.

Here's how you might use extern templates with separate files:

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

1// MyTemplate.cpp
2#include <iostream>
3#include "MyTemplate.h"
4
5template <typename T>
6void MyTemplate<T>::foo() {
7  std::cout << "MyTemplate::foo()\n";
8}
9
10// Explicit instantiation
11template class MyTemplate<int>;

1// main.cpp
2#include "MyTemplate.h"
3
4int main() {
5  MyTemplate<int> obj;
6  obj.foo();
7}

1MyTemplate::foo()

1. Reduced Compile Time: The main benefit is faster compilation. The compiler won't generate code for MyTemplate<int> in every translation unit that includes "MyTemplate.h".
2. Linker Dependency: You must ensure that the translation unit with the explicit instantiation is linked into your program. If not, you'll get linker errors.
3. Careful Management: You need to manually manage which instantiations are extern and which are explicitly instantiated.
4. Limited to Specific Types: You need to declare extern templates for each type you want to use this way.
5. Potential for ODR Violations: If you accidentally have multiple definitions of the same template instantiation, you might violate the One Definition Rule.

• Use extern templates for frequently used template instantiations in large projects.
• Keep a centralized location (like a .cpp file) for all your explicit instantiations.
• Be consistent with your use of extern templates across your project.
• Consider using a tool or script to manage extern template declarations and instantiations in large projects.

In this example, we instantiate our template for multiple sets of template arguments:

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

1// MyTemplate.cpp
2#include <iostream>
3#include "MyTemplate.h"
4
5template <typename T>
6void MyTemplate<T>::foo() {
7  std::cout << "MyTemplate::foo() with "
8    << typeid(T).name() << "\n";
9}
10
11template class MyTemplate<int>;
12template class MyTemplate<double>;

Remember, while extern templates can significantly reduce compile times in large projects, they also add complexity to your code organization.

Use them judiciously, and always measure the impact on your specific project to ensure they're providing the desired benefits.