在前面我们介绍了《C++之函数模板》
今天我们继续来介绍模板的另外一种形式：类模板。
与模板函数相似，类也可以被一种或多种类型参数化，标准库中的容器类就是一个具有这种特性的典型例子。
类模板的声明
我们通过一段例子代码了解一下类模板的声明：
// 类模板声明
template <typename T>
class MyClass{
public:
T getT();
void setT(T t);
private:
T t;
};
// 类成员函数实现
template<typename T>
T MyClass<T>::getT() {
return t;
}
template<typename T>
void MyClass<T>::setT(T t) {
this->t = t;
}
int main(int argc, char* argv[]) {
// 类模板使用
MyClass<int> myClass;
myClass.setT(10);
std::cout << "myClass:" << myClass.getT() << std::endl;
return 0;
}首先也是使用关键字template和关键字typename对类模板进行声明，当我们将一个类声明为类模板之后，模板参数T可以像其他任何类型一样，用于声明成员变量和成员函数。
类模板的成员函数
通过上面的实例代码，我们看到在类模板的声明内部函数时如果用到模板参数T，则不用再次使用template<typename T>，但是当实现类模板的内部函数时，如果用到了模板参数T，则还需要在函数的上方 使用template<typename T>进行标记。
也即是说为了定义类模板的成员函数，你必须指定该成员函数是一个函数模板，而且你还需要使用这个类模板的完整类型限定符。
或许你觉得每次定义类模板的内部函数都要使用到模板声明，当内部函数较多时，则会产生非常多的不必要的声明，此时我们可以直接在类的内部声明加定义同时实现：
// 类模板声明
template <typename T>
class MyClass{
public:
// 声明加定义
T getT(){
return t;
}
// 声明加定义
void setT(T t){
this->t = t;
}
private:
T t;
};在类模板中只有那些被调用的成员函数，才会产生这些函数的实例化代码。对于类模板，成员函数只有在被使用的时候才会被实例化。 显然，这样可以节省空间和时间；另一个好处是：对于那些“未能提供所有成员函数中所有操作的”类型，你也可以使用该类型来实例化类模板， 只要对那些“未能提供某些操作的”成员函数，模板内部不使用即可。
类模板的特例化
同模板函数的特化一样，你可以用模板实参来特化类模板，和函数模板的重载类似，通过特化类模板，我们可以优化基于某种特定类型的实现。
在类模板的特化过程中有两个步骤：
- 在类的起始处声明一个template<>，接下来声明用来特化类模板的类型。这个类型被用作模板实参，且必须在类名的后面直接指定。
- 进行类模板的特化时，每个成员函数都必须重新定义为普通函数，原来模板函数中的每个T也相应地被进行特化的类型取代。
下面是一个模板类特化的例子：
// 类模板声明
template <typename T>
class MyClass{
public:
// 声明加定义
T getT(){
return t;
}
// 声明加定义
void setT(T t){
this->t = t;
}
private:
T t;
};
// 类模板声明
template <>
class MyClass<std::string>{
public:
// 声明加定义
std::string getT(){
return t;
}
// 声明加定义
void setT(std::string t){
std::cout << "调用特化类模板 setT" << std::endl;
this->t = t;
}
private:
std::string t;
};
int main(int argc, char* argv[]) {
// 类模板使用
MyClass<std::string> myClass;
myClass.setT("hello word");
std::cout << "myClass:" << myClass.getT() << std::endl;
return 0;
}模板源码组织模式
模板源码的组织模式有好多种，这里只介绍两种常用的:分别是包含模式和关键字export的分离模式。
包含模式可以说是最常用也是最推荐的一种模式。这种模式就是将模板类的声明和定义都放在同一个文件中，这个文件一般是扩展名为.hpp的文件。
下面是一个类模板声明定义和使用分开在不同文件的例子：
MyClass.hpp
#include <iostream>
#include <memory>
// 类模板声明
template <typename T>
class MyClass{
public:
// 声明
T getT();
void setT(T t);
private:
T t;
};
template<typename T>
T MyClass<T>::getT() {
return t;
}
template<typename T>
void MyClass<T>::setT(T t) {
this->t = t;
}在main函数中使用模板main.cpp:
main.cpp
#include <iostream>
#include <memory>
#include "MyClass.hpp"
int main(int argc, char* argv[]) {
// 类模板使用
MyClass<std::string> myClass;
myClass.setT("hello word");
std::cout << "myClass:" << myClass.getT() << std::endl;
return 0;
}很明显，包含模式因为包含了类模板的定义实现，因而明显增加了包含头文件.hpp的开销，这会导致大大增加了编译复杂程序所耗费的时间。 然而随着现代的机器性能提升，这里带来的编译开销基本可以忽略不计，因此这种模式成为了使用最多的模式。
下面我们再来看看关键字export的分离模式。
关键字export的功能使用是非常简单的：在一个文件里面定义模板，并在模板的定义和（非定义的）声明的前面加上关键字export。
还是以上面的代码为例：
(1) MyClass.h
#include <iostream>
#include <memory>
// 类模板声明
export template <typename T>
class MyClass{
public:
// 声明
T getT();
void setT(T t);
private:
T t;
};(2) MyClass.cpp
#include "MyClass.h"
export template<typename T>
T MyClass<T>::getT() {
return t;
}
export template<typename T>
void MyClass<T>::setT(T t) {
this->t = t;
}以上代码能否编译通过取决于你的编译器，大部分是无法编译通过的，这代码和包含模式对比起来是不是有一种脱裤子放屁的感觉？
看起来关键字export的分离模式更加符合C++源码组织习惯，为什么这种写法再C++的模板没有流行起来呢？ 这是因为在C++标准推出几年之后，也就只有极少的公司真正提供了对export关键字的支持。于是，export这个特性未能像其他C++特性那样广为流传， 这就使得程序员在很多编译器下都不能正常使用export的分离模式。
