具体看下面的栗子：

//test.h
#ifndef ALGORITHMS_TEST_H
#define ALGORITHMS_TEST_H
template <typename T>
class Foo
    T bar;
public:
    //void doSomething(T param) {/* do stuff using T */}
    void doSomething(T param);
#endif //ALGORITHMS_TEST_H
//test.cpp
#include<iostream>
#include "test.h"
template <typename T>
void  Foo<T>::doSomething(T param) {
    std::cout << param << std::endl;
//main.cpp
#include "test.h"
int main() {
    Foo<int> f;
    f.doSomething(3);
    return 0;
编译报连接错误

ld: symbol(s) not found for architecture x86_64

clang: error: linker command failed with exit code 1 (use -v to see invocation)

make[3]: *** [Algorithms] Error 1
为什么模版类的声明和实现分开会出现连接问题呢
因为需要单独编译，并且模板是实例化样式的多态性；

在实例化模板时，编译器会使用给定的模板参数创建一个新类。例如：
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 */}
因此，编译器需要访问方法的实现，以使用template参数实例化它们（在这种情况下为int）。如果这些实现不在头文件中，则将无法访问它们，因此编译器将无法实例化模板。
具体解释如下：
foo.h
    声明的接口 class MyClass<T>
foo.cpp
    定义执行 class MyClass<T>
bar.cpp
    用途 MyClass<int>
单独编译意味着我应该能够独立于bar.cpp编译foo.cpp。编译器在每个编译单元上完全独立地完成分析、优化和代码生成的所有艰苦工作;我们不需要做整个程序分析。只有链接器需要一次处理整个程序，链接器的工作大大简化了。
当我编译foo.cpp时，bar.cpp甚至不需要存在，但是我仍然应该可以将foo.o与bar.o一起使用。刚刚生成的文件，而无需重新编译foo.cpp。甚至可以将foo.cpp编译成动态库，而无需foo.cpp即可将其分发到其他位置，并与在我编写foo.cpp之后多年编写的代码链接。
"实例化样式多态性”表示模板MyClass<T>并不是真正的通用(范型)类，它不能被编译成可以处理任何T值的代码。这将增加开销，如装箱，需要传递函数指针到分配器和构造器，等等。c++模板的目的是避免编写几乎相同的类MyClass_int、类MyClass_float等，但仍然能够编译代码，结束了就像我们分别编写每个版本一样。因此，模板实际上是模板。类模板不是类，而是为T我们遇到的每个类创建新类的秘诀。模板不能被编译成代码，只有实例化模板的结果可以被译。
因此，在编译foo.cpp时，编译器无法通过看到bar.cpp来知道需要MyClass<int>。它可以看到模板MyClass<T>，但不能为此编译出相应的代码（它是模板，而不是类）。并且在编译bar.cpp时，编译器可以看到它需要创建一个MyClass<int>，但是看不到该模板MyClass<T>（只能在foo.h中看到其接口，不能看到具体类成员函数的具体实现等），因此无法创建它。
如果Foo.cpp中本身使用MyClass<int>，将在编译时会产生对应代码在Foo.cpp中，因此当文件bar.o链接到文件foo.o他们可以连接并工作。我们可以利用这一事实，通过编写单个模板，在.cpp文件中实现一组有限的模板实例化。但bar.cpp无法将模板作为模板实例化它的类型;它只能使用foo.cpp的作者认为提供的模板化类的已存在版本。
您可能会认为，在编译模板时，编译器应“生成所有版本”，并且在链接过程中会滤除从未使用过的版本。除了庞大的开销和极端的困难之外，这种方法还会面临困难，因为指针和数组之类的“类型修饰符”功能甚至允许内置类型产生无限数量的类型，当我现在扩展程序时会发生什么通过添加:
baz.cpp
    声明并实现class BazPrivate，并使用MyClass<BazPrivate>
除非我们：
1、每当我们改变程序中的任何其他文件时，必须重新编译foo.cpp，以防它添加了一个新的实例化MyClass<T>
2、要求baz.cpp包含（可能通过标头包含）的完整模板MyClass<T>，以便编译器可以MyClass<BazPrivate>在编译baz.cpp时生成。
没有人喜欢(1)，因为整个程序分析的编译系统需要很长时间来编译，而且如果没有源代码，就不可能分发已编译的库。所以我们用(2)代替。
常见的解决方案是将模板声明写入头文件中，然后在实现文件中实现该类（例如.tpp），并在头末尾包含该实现文件。
//test.h
template <typename T>
struct Foo
    void doSomething(T param);
#include "test.tpp"
//test.tpp
template <typename T>
void Foo<T>::doSomething(T param)
    //implementation
这样，实现仍与声明分开，但编译器可以访问;
另外一种代替的解决方案：使实现分离，并显式实例化所需的所有模板实例：
//Foo.h
//no implementation
//template <typename T> struct Foo { ... };
template <typename T>
class Foo
    T bar;
public:
    //void doSomething(T param) {/* do stuff using T */}
    void doSomething(T param);
//Foo.cpp
// implementation of Foo's methods
// explicit instantiations
template <typename T>
void  Foo<T>::doSomething(T param) {
    std::cout << param << std::endl;
template class Foo<int>;  //相关的实例化代码由编译器产生
template class Foo<float>;
//main.cpp
#include "test.hpp"
int main(int argc, const char * argv[]) {   
    Foo<int> f;
    f.doSomething(3);
    return 0;
/* 编译运行成功：
    3  Program ended with exit code: 0
参考：https://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file