Precompiled Headers with Template Classes

Yes, you can use precompiled headers (PCH) with template classes split across files. This can significantly reduce compilation times, especially in large projects.

Let's explore how to implement this and some considerations to keep in mind.

First, create a header file for precompilation:

1// stdafx.h
2#pragma once
3
4// Standard library headers
5#include <vector>
6#include <string>
7#include <iostream>
8
9// Your common project headers
10#include "CommonTypes.h"
11#include "Utilities.h"
12
13// Template class declarations
14#include "MyTemplate.h"

Now, let's see how to use this with a split template class:

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

1// MyTemplate.cpp
2#include "MyTemplate.h"
3#include "stdafx.h"  // Use the precompiled header
4
5template <typename T>
6void MyTemplate<T>::foo() {
7  std::cout << "foo called\n";
8}
9
10template <typename T>
11void MyTemplate<T>::bar() {
12  std::cout << "bar called\n";
13}
14
15// Explicit instantiations
16template class MyTemplate<int>;
17template class MyTemplate<std::string>;

1. Faster Compilation: PCH can significantly reduce compilation times, especially for large projects with many templates.
2. Consistency: Ensures all files use the same version of included headers.
3. Reduced I/O: The compiler reads the precompiled header once, reducing disk I/O.
4. Memory Usage: PCH can increase memory usage during compilation.
5. Maintenance: You need to rebuild the PCH if any included header changes.

1. Include Stable Headers: Put only stable, rarely changing headers in your PCH.
2. Order Matters: The order of includes in the PCH should match the order in your source files.
3. Explicit Instantiations: Keep explicit instantiations in non-precompiled source files.
4. Avoid Over-inclusion: Don't include everything in your PCH. Focus on frequently used headers.

Here's an example program that uses multiple templates:

1// stdafx.h
2#pragma once
3#include <iostream>
4#include <string>
5#include <vector>
6
7#include "TemplateA.h"
8#include "TemplateB.h"

1// TemplateA.cpp
2#include "stdafx.h"
3
4template <typename T>
5void TemplateA<T>::method() {
6  /* implementation */
7}
8
9template class TemplateA<int>;

1// TemplateB.cpp
2#include "stdafx.h"
3
4template <typename T>
5void TemplateB<T>::method() {
6  /* implementation */
7}
8
9template class TemplateB<double>;

1// main.cpp
2#include "stdafx.h"
3
4int main() {
5  TemplateA<int> a;
6  TemplateB<double> b;
7  a.method();
8  b.method();
9}

Remember, while precompiled headers can significantly speed up compilation, they require careful management.

Always measure the impact on your specific project to ensure they're providing the desired benefits. In some cases, you might find that modules (if available in your C++ version) offer similar benefits with easier maintenance.