这意味着定义模板类的方法实现的最可移植的方式是在模板类定义中定义它们。

template < typename ... >
class MyClass
{

    int myMethod()
    {
       // Not just declaration. Add method implementation here
    }
};

单独实现的方法如下。

内部_内部.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或其他工具时都很烦人。

这意味着定义模板类的方法实现的最可移植的方式是在模板类定义中定义它们。

template < typename ... >
class MyClass
{

    int myMethod()
    {
       // Not just declaration. Add method implementation here
    }
};

注意：没有必要将实现放在头文件中，请参阅答案末尾的替代解决方案。

无论如何，代码失败的原因是，在实例化模板时，编译器使用给定的模板参数创建一个新类。例如：

template<typename T>
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo<int> f; 

当读取这一行时，编译器将创建一个新类（让我们称之为FooInt），这相当于以下内容：

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
}

因此，编译器需要访问方法的实现，以使用模板参数（在本例中为int）实例化它们。如果这些实现不在标头中，那么它们将无法访问，因此编译器将无法实例化模板。

对此的常见解决方案是在头文件中写入模板声明，然后在实现文件（例如.tpp）中实现类，并在头的末尾包含该实现文件。

食品h

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

#include "Foo.tpp"

食品.tpp

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

这样，实现仍然与声明分离，但编译器可以访问。

替代解决方案

另一个解决方案是保持实现分离，并显式实例化您需要的所有模板实例：

食品h

// no implementation
template <typename T> struct Foo { ... };

食品.cpp

// implementation of Foo's methods

// explicit instantiations
template class Foo<int>;
template class Foo<float>;
// You will only be able to use Foo with int or float

如果我的解释不够清楚，你可以看看这个主题的C++超级常见问题解答。

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

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

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

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

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

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

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

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

我采用了以下方法，这也适用于较旧的编译器（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;
}

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