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

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

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

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

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

只是在这里添加一些值得注意的内容。当模板类的方法不是函数模板时，可以在实现文件中定义它们。

myQueue.hpp：

template <class T> 
class QueueA {
    int size;
    ...
public:
    template <class T> T dequeue() {
       // implementation here
    }

    bool isEmpty();

    ...
}    

myQueue.cpp：

// implementation of regular methods goes like this:
template <class T> bool QueueA<T>::isEmpty() {
    return this->size == 0;
}


main()
{
    QueueA<char> Q;

    ...
}

在头文件中编写声明和定义是一个好主意的另一个原因是为了可读性。假设Utility.h中有这样一个模板函数：

template <class T>
T min(T const& one, T const& theOther);

在Utility.cpp中：

#include "Utility.h"
template <class T>
T min(T const& one, T const& other)
{
    return one < other ? one : other;
}

这需要这里的每个T类实现小于运算符（<）。当您比较两个尚未实现“<”的类实例时，它将抛出编译器错误。

因此，如果将模板声明和定义分开，则无法仅读取头文件来查看此模板的输入和输出，以便在自己的类上使用此API，尽管在这种情况下编译器会告诉您需要重写哪个运算符。

实际上，在C++11之前，该标准定义了export关键字，它可以在头文件中声明模板并在其他地方实现它们。在某种程度上讲。并非如此，正如唯一实现过该功能的人所指出的：

幻影优势#1：隐藏源代码。许多用户表示，他们希望通过使用导出不再需要为类的成员/非成员函数模板和成员函数提供定义模板。这不是真的。在导出的情况下，库编写者仍然必须提供完整的模板源代码或其直接因为实例化需要完整的信息。[...]

幻影优势#2：快速构建，减少依赖性。许多用户希望导出将允许真正的分离将模板编译为目标代码，他们希望这样可以加快构建速度。这不是因为导出模板的编译确实是独立的，但与目标代码无关。相反，出口几乎总是构建速度较慢，因为至少在预链接时仍必须完成相同数量的编译工作。出口甚至不减少模板定义之间的依赖性，因为依赖性是内在的，独立于文件组织。

没有一个流行的编译器实现了这个关键字。该功能的唯一实现是由Edison Design Group编写的前端，由Comeau C++编译器使用。所有其他人都要求您在头文件中编写模板，因为编译器需要模板定义来进行适当的实例化（正如其他人已经指出的那样）。

因此，ISO C++标准委员会决定删除C++11模板的导出功能。

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

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

#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];
    }

尽管上面有很多很好的解释，但我缺少一种将模板分离为页眉和正文的实用方法。

我主要担心的是，当我更改其定义时，避免重新编译所有模板用户。

对我来说，在模板主体中包含所有模板实例不是一个可行的解决方案，因为模板作者可能不知道其使用情况，模板用户可能无权修改它。

我采用了以下方法，这也适用于较旧的编译器（gcc 4.3.4，aCC A.03.13）。

对于每个模板的使用，在其自己的头文件（从UML模型生成）中都有一个typedef。它的主体包含实例化（最终在一个库中，该库在末尾链接）。

模板的每个用户都包含该头文件并使用typedef。

示意图示例：

MyTemplate.h：

#ifndef MyTemplate_h
#define MyTemplate_h 1

template <class T>
class MyTemplate
{
public:
  MyTemplate(const T& rt);
  void dump();
  T t;
};

#endif

我的模板.cpp：

#include "MyTemplate.h"
#include <iostream>

template <class T>
MyTemplate<T>::MyTemplate(const T& rt)
: t(rt)
{
}

template <class T>
void MyTemplate<T>::dump()
{
  cerr << t << endl;
}

MyInstantiatedTemplate.h：

#ifndef MyInstantiatedTemplate_h
#define MyInstantiatedTemplate_h 1
#include "MyTemplate.h"

typedef MyTemplate< int > MyInstantiatedTemplate;

#endif

我的实例化模板.cpp：

#include "MyTemplate.cpp"

template class MyTemplate< int >;

main.cpp：

#include "MyInstantiatedTemplate.h"

int main()
{
  MyInstantiatedTemplate m(100);
  m.dump();
  return 0;
}

这样，只需要重新编译模板实例，而不是所有模板用户（和依赖项）。