模版的编译
c++ primer p657
- 一般来说，如果你的项目没有混合使用 C 和 C++ 语言，那么你使用 .h 和 .cpp 是没有问题的。否则你将C和C++的头文件进行分离,因为通常我们把C和C++分离编译，再统一链接;
- 函数经过编译系统的翻译成汇编，函数名对应着汇编标号。 因为C编译函数名与得到的汇编代号基本一样，如：fun()=>_fun, main=>_main ；但是C++中函数名与得到的汇编代号有比较大的差别。 如：由于函数重载，函数名一样，但汇编代号绝对不能一样。
- 为了区分，编译器会把函数名和参数类型合在一起作为汇编代号， 这样就解决了重载问题。具体如何把函数名和参数类型合在一起， 要看编译器的帮助说明了。
- 这样一来，如果C++调用C，如fun(),则调用名就不是C的翻译结果_fun, 而是带有参数信息的一个名字，因此就不能调用到fun（），为了解决 这个问题，加上extern "C"表示该函数的调用规则是C的规则，则调用 时就不使用C++规则的带有参数信息的名字，而是_fun,从而达到调用 C函数的目的。
具体看下面的栗子：
//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
