模板通常用于标头中，因为编译器需要实例化不同版本的代码，这取决于为模板参数给定/推导的参数，并且（作为程序员）更容易让编译器多次重新编译同一代码，然后进行重复数据消除。请记住，模板并不直接表示代码，而是该代码的多个版本的模板。当您在.cpp文件中编译非模板函数时，您正在编译一个具体的函数/类。模板的情况并非如此，它可以用不同的类型实例化，也就是说，当用具体类型替换模板参数时，必须发出具体的代码。

export关键字有一个功能，用于单独编译。导出功能在C++11中被弃用，而且，AFAIK中只有一个编译器实现了它。你不应该利用出口。在C++或C++11中，单独编译是不可能的，但在C++17中，如果概念允许，我们可以有一些单独编译的方法。

为了实现单独的编译，必须可以进行单独的模板体检查。似乎可以用概念来解决问题。看看最近发表在标准委员会会议。我认为这不是唯一的要求，因为您仍然需要为用户代码中的模板代码实例化代码。

模板的单独编译问题我想也是迁移到模块时出现的问题，目前正在进行中。

编辑：截至2020年8月，模块已经成为C++的现实：https://en.cppreference.com/w/cpp/language/modules

尽管标准C++没有这样的要求，但一些编译器要求所有函数和类模板都必须在使用的每个翻译单元中可用。实际上，对于这些编译器，模板函数的主体必须在头文件中可用。重复：这意味着这些编译器不允许在.cpp文件等非头文件中定义它们

有一个导出关键字可以缓解这个问题，但它离可移植性还很远。

在实际将模板编译成目标代码之前，需要由编译器实例化模板。只有当模板参数已知时，才能实现此实例化。现在想象一个场景，其中模板函数在a.h中声明，在a.pp中定义，并在b.cpp中使用。编译a.pp时，不一定知道即将到来的编译b.cpp将需要模板的实例，更不用说是哪个特定的实例。对于更多的头文件和源文件，情况可能会很快变得更加复杂。

有人会说，编译器可以更聪明地“前瞻”模板的所有用途，但我确信创建递归或其他复杂场景并不困难。顺便说一句，编译器不会再这样做了。正如Anton所指出的，一些编译器支持模板实例化的显式导出声明，但并非所有编译器都支持它（现在？）。

单独实现的方法如下。

内部_内部.h

template <typename T>
struct Foo
{
    void doSomething(T param);
};

foo.tpp文件

#include "inner_foo.h"

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

小时

#include <foo.tpp>

主.cpp

#include <foo.h>

inner_fo.h具有前向声明。foo.tpp具有实现并包括inner_fo.h；而foo.h只有一行，包括foo.tpp。

编译时，将foo.h的内容复制到foo.tpp，然后将整个文件复制到foo.h，然后进行编译。这样，没有任何限制，并且命名是一致的，以换取一个额外的文件。

我这样做是因为代码的静态分析器在*.tpp中看不到类的前向声明时会中断。这在任何IDE中编写代码或使用YouCompleteMe或其他工具时都很烦人。

我建议看看这个gcc页面，它讨论了模板实例化的“cfront”和“borland”模型之间的权衡。

https://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/Template-Instantiation.html

“borland”模型符合作者的建议，提供完整的模板定义，并多次编译。

它包含关于使用手动和自动模板实例化的明确建议。例如，“-repo”选项可用于收集需要实例化的模板。或者另一个选项是使用“-fno隐式模板”禁用自动模板实例化，以强制手动模板实例化。

根据我的经验，我依赖于为每个编译单元实例化的C++标准库和Boost模板（使用模板库）。对于我的大型模板类，我为所需的类型进行了一次手动模板实例化。

这是我的方法，因为我提供的是一个工作程序，而不是用于其他程序的模板库。这本书的作者Josuttis在模板库方面做了大量工作。

如果我真的担心速度，我想我会探索使用预编译头https://gcc.gnu.org/onlinedocs/gcc/Precompiled-Headers.html

这在许多编译器中得到了支持。然而，我认为使用模板头文件时，预编译头文件会很困难。

我必须写一个模板类，这个例子对我很有用

下面是一个动态数组类的示例。

#ifndef dynarray_h
#define dynarray_h

#include <iostream>

template <class T>
class DynArray{
    int capacity_;
    int size_;
    T* data;
public:
    explicit DynArray(int size = 0, int capacity=2);
    DynArray(const DynArray& d1);
    ~DynArray();
    T& operator[]( const int index);
    void operator=(const DynArray<T>& d1);
    int size();
    
    int capacity();
    void clear();
    
    void push_back(int n);
    
    void pop_back();
    T& at(const int n);
    T& back();
    T& front();
};

#include "dynarray.template" // this is how you get the header file

#endif

现在，在.template文件中，您可以像往常一样定义函数。

template <class T>
DynArray<T>::DynArray(int size, int capacity){
    if (capacity >= size){
        this->size_ = size;
        this->capacity_ = capacity;
        data = new T[capacity];
    }
    //    for (int i = 0; i < size; ++i) {
    //        data[i] = 0;
    //    }
}

template <class T>
DynArray<T>::DynArray(const DynArray& d1){
    //clear();
    //delete [] data;
    std::cout << "copy" << std::endl;
    this->size_ = d1.size_;
    this->capacity_ = d1.capacity_;
    data = new T[capacity()];
    for(int i = 0; i < size(); ++i){
        data[i] = d1.data[i];
    }
}

template <class T>
DynArray<T>::~DynArray(){
    delete [] data;
}

template <class T>
T& DynArray<T>::operator[]( const int index){
    return at(index);
}

template <class T>
void DynArray<T>::operator=(const DynArray<T>& d1){
    if (this->size() > 0) {
        clear();
    }
    std::cout << "assign" << std::endl;
    this->size_ = d1.size_;
    this->capacity_ = d1.capacity_;
    data = new T[capacity()];
    for(int i = 0; i < size(); ++i){
        data[i] = d1.data[i];
    }
    
    //delete [] d1.data;
}

template <class T>
int DynArray<T>::size(){
    return size_;
}

template <class T>
int DynArray<T>::capacity(){
    return capacity_;
}

template <class T>
void DynArray<T>::clear(){
    for( int i = 0; i < size(); ++i){
        data[i] = 0;
    }
    size_ = 0;
    capacity_ = 2;
}

template <class T>
void DynArray<T>::push_back(int n){
    if (size() >= capacity()) {
        std::cout << "grow" << std::endl;
        //redo the array
        T* copy = new T[capacity_ + 40];
        for (int i = 0; i < size(); ++i) {
            copy[i] = data[i];
        }
        
        delete [] data;
        data = new T[ capacity_ * 2];
        for (int i = 0; i < capacity() * 2; ++i) {
            data[i] = copy[i];
        }
        delete [] copy;
        capacity_ *= 2;
    }
    data[size()] = n;
    ++size_;
}

template <class T>
void DynArray<T>::pop_back(){
    data[size()-1] = 0;
    --size_;
}

template <class T>
T& DynArray<T>::at(const int n){
    if (n >= size()) {
        throw std::runtime_error("invalid index");
    }
    return data[n];
}

template <class T>
T& DynArray<T>::back(){
    if (size() == 0) {
        throw std::runtime_error("vector is empty");
    }
    return data[size()-1];
}

template <class T>
T& DynArray<T>::front(){
    if (size() == 0) {
        throw std::runtime_error("vector is empty");
    }
    return data[0];
    }