C++ 模板类的声明与实现分离问题（模板实例化）
c++在写模版函数时（template
否则,将产生错误信息：
严重性 代码 说明 项目 文件 行 禁止显示状态 错误 LNK2019 无法解析的外部符号 "public: void __thiscall XXX
有什么办法可以是西安模板类的声明与实现分离（模板实例化）问题吗？
模板实例化有什么好处？
- 减少编译时间。
- 使得类定义与实现分离。
减少编译时间
一般来说，如果你的项目没有混合使用 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函数的目的。
//header.hpp
#pragma once
extern "C"
{
#include "header.h" // 真正的 C header
}好的，说会正事 ~
//foo.hpp (.h和.hpp就如同.c和.cpp似的)
template
struct Foo {
void f();
};
//foo.cpp
template
void Foo::f() {}
template class Foo;
template class Foo; 在标头中声明实例化：
extern template class A; 并在一个源文件中定义它：
template class A; 现在它只会被实例化一次，而不是每个翻译单元，这可能会加快速度。
首先需要知道的是把模版类的定义和实现分开写了，编译将会出错。
C++中每一个对象所占用的空间大小，是在编译的时候就确定的，在模板类没有真正的被使用之前，编译器是无法知道，模板类中使用模板类型的对象的所占用的空间的大小的。只有模板被真正使用的时候，编译器才知道，模板套用的是什么类型，应该分配多少空间。这也就是模板类为什么只是称之为模板，而不是泛型的缘故。
既然是在编译的时候，根据套用的不同类型进行编译，那么，套用不同类型的模板类实际上就是两个不同的类型，也就是说，stack
如上图所示，很简短的六行代码，用的是STL里面的stack，stack
所以模板类的实现，脱离具体的使用，是无法单独的编译的；把声明和实现分开的做法也是不可取的，必须把实现全部写在头文件里面。为了清晰，实现可以不写在class后面的花括号里面，可以写在class的外面。
实现分离
显式实例化允许您创建模板化类或函数的实例化，而无需在代码中实际使用它。因为在创建使用模板进行分发的库（.lib）文件时这很有用，所以未将实例化的模板定义放入对象（.obj）文件中。
（例如，libstdc ++包含std::basic_string（是std::string）的显式实例化，所以每次使用函数时std::string，都不需要将相同的函数代码复制到对象。编译器只需要将它们引用（链接）到libstdc ++。）
显示实例化时，当你是只有一个 cpp 的情况.可能没有什么问题。但 如果有多个 cpp 文件再使用这个模版, 你必须把它放在头文件里, 然后每个 cpp 都要 #include 这个头文件. 显示实例化之后头文件里只需要声明, 然后在其中一个 cpp 里面实现并显示实例化, 其它的 cpp 就可以直接用了.
在 C++ 中定义普通的类的时候，比较清晰和普遍的做法是在 .h 文件中声明类的接口，如果有 inline 函数也一并放在 .h 中的 class 关键字中。然后在 .cpp 文件中实现 .h 中声明的接口。
在定义模板类时，如果要将接口与实现分离会略有不同。如果把模板类的实现像普通类一样放在 .cpp 文件中链接器会报错。
有两个方法可以实现模板类的接口和实现在文件中的分离：
一个前提
“类模板的成员函数是一个普通函数。但是类模板的每个实例都有其自己版本的成员函数。因此类模板的成员函数具有和模板相同的模板参数。因此定义在类模板之外的成员函数就必须以关键字 template 开始，后接类模板参数列表。”
——《C++ Primer》中文版，第五版，P585
使用 .tpp 文件实现类模板的接口与实现的文件分离
比如说有这样一个模板类，这是它的接口：
template
class TestTemplate{
public:
TestTemplate(Node node):
data(node) { }
Node data;
void print();
}; 这是它的实现：
template
void TestTemplate::print(){
std::cout << "TestTemplate " << data << std::endl;
}
如果把它们分别放在 .h 和 .cpp 文件中，链接器会报错，提示找不到实现。
在 .h 文件中模板类的实现下加这一句：
#include "TestTemplate.tpp"
然后把实现放在名为 TestTemplate.tpp 文件中，即可。
使用显式声明实现类模板的接口与实现的文件分离
假设上面那个类的接口与实现分别放在了 .h 和 .cpp 文件中。然后在 .cpp 文件中显式的声明要使用的模板类实例，比如：
template class TestTemplate;
然后，使用 TestTemplate
template class TestTemplate;
template class TestTemplate;
就是说只能只用已经显式声明过的模板类实例。
如果您定义了一个模板类，您只想使用几个显式类型。
将模板声明放在头文件中就像普通类一样。
将模板定义放在源文件中，就像普通类一样。
然后，在源文件的末尾，显式地仅实例化您想要可用的版本。
我的实验：
//StringAdapter.h
#pragma once
#include
#include
using namespace std;
template
class StringAdapter
{
public:
StringAdapter(T* data);
void doAdapterStuff();
private:
T* m_data;
};
#include "StringAdapter.tpp"
// StringAdapter.tpp
#include "StringAdapter.h"
template
StringAdapter::StringAdapter(T* data) : m_data(data)
{
cout << m_data << endl;
}
template
void StringAdapter::doAdapterStuff()
{
/* Manipulate a string */
cout << "hello" << endl;
}
// main.cpp
#include "StringAdapter.h"
// Note: Main can not see the definition of the template from here (just the declaration)
// So it relies on the explicit instantiation to make sure it links.
int main()
{
StringAdapter x("hi There");
x.doAdapterStuff();
}
stackoverflow 中愚蠢的例子Silly example:：
// StringAdapter.h
template
class StringAdapter
{
public:
StringAdapter(T* data);
void doAdapterStuff();
private:
std::basic_string m_data;
};
typedef StringAdapter StrAdapter;
typedef StringAdapter WStrAdapter; source：
// StringAdapter.cpp
#include "StringAdapter.h"
template
StringAdapter::StringAdapter(T* data)
:m_data(data)
{}
template
void StringAdapter::doAdapterStuff()
{
/* Manipulate a string */
}
// Explicitly instantiate only the classes you want to be defined.
// In this case I only want the template to work with characters but
// I want to support both char and wchar_t with the same code.
template class StringAdapter;
template class StringAdapter; Main：
#include "StringAdapter.h"
// Note: Main can not see the definition of the template from here (just the declaration)
// So it relies on the explicit instantiation to make sure it links.
int main()
{
StrAdapter x("hi There");
x.doAdapterStuff();
}
一些有趣的小知识
《C++ Template》第六章讲过这个问题
组织模板代码有三种方式
1.包含模型（常规写法 将实现写在头文件中）
2.显式实例化（实现写在cpp文件中，使用template class语法进行显式实例化）
3.分离模型（使用C++ export关键字声明导出）
第三种方式理论最优，但是实际从C++标准提出之后主流编译器没有支持过，并且在最新的C++11标准中已经废除此特性，export关键字保留待用。
那么实际上能够使用的实现分离也就只有显式实例化
比较有意思的是，《C++ Template》书中作者建议代码为分离模型做准备，等待编译器支持之后替换，没想到最终这个特性被C++标准废弃了。
参考：https://www.zhihu.com/question/20630104
https://bbs.csdn.net/topics/380250382
http://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file
https://stackoverflow.com/questions/2351148/explicit-instantiation-when-is-it-used
google搜索：Explicit template instantiation benefits