这是完全正确的，因为编译器必须知道它的分配类型。模板类、函数、枚举等。。如果要将头文件公开或作为库的一部分（静态或动态），则也必须在头文件中实现，因为头文件不像c/cpp文件那样编译。如果编译器不知道该类型，则无法编译它。在.Net中，它可以编译，因为所有对象都派生自Object类。这不是.Net。

在头文件中编写声明和定义是一个好主意的另一个原因是为了可读性。假设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，尽管在这种情况下编译器会告诉您需要重写哪个运算符。

单独实现的方法如下。

内部_内部.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 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;
}

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

这里有很多正确的答案，但我想补充一下（为了完整）：

如果在实现cpp文件的底部，对模板将使用的所有类型进行显式实例化，链接器将能够像往常一样找到它们。

编辑：添加显式模板实例化示例。在定义模板并定义所有成员函数后使用。

template class vector<int>;

这将实例化（从而使链接器可用）类及其所有成员函数（仅限）。类似的语法适用于函数模板，因此如果您有非成员运算符重载，则可能需要对这些重载执行相同的操作。

上面的例子是非常无用的，因为vector是在头文件中完全定义的，除非公共include文件（预编译头文件？）使用外部模板类vector＜int＞，以防止它在所有其他使用vector的（1000？）文件中实例化。

我建议看看这个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

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