模板是C++中泛型编程的基础，一个模板就是一个创建类或函数的公式或者说是代码生成器，当使用模板类型时，编译器会生成特定的类或函数，这个过程发生在编译时。C++的模板属于类型膨胀，是真泛型，而Java里的泛型属于类型擦除，是伪泛型。
模板定义
模板定义以关键字template开始，后跟以个模板参数列表，这是一个逗号分隔的一个或多个模板参数的列表，用尖括号括起来。
template<typename T,typename M>
模板参数表示在类或函数定义中用到的类型或值，在使用模板时，我们显式或隐式指定模板实参，将其绑定到模板参数上。
模板编译
为了生成一个实例化版本，编译器需要掌握函数或类模板成员函数的定义，所以模板的声明和定义应该都放在头文件里，如果是只用于源文件内部则可以不放在头文件。
函数模板
当我们调用一个函数模板时，编译器用函数实参来为我们推断模板实参，然后为我们实例化一个特定版本的函数。下面的代码会实例化出两个不同版本的compare。
template<typename T>
bool compare(const T& value1, const T& value2)
{
return value1 == value2;
}
int main()
{
cout << compare(1, 10) << endl;
cout << compare("11", "11") << endl;
system("pause");
}
类模板
与函数模板不同，编译器不能为类模板推断模板参数类型，为了使用类模板，我们必须在模板名后的尖括号中提供额外的信息，例如vector<int>。
template<typename T>
class Printer
{
public:
Printer<T>(T value):value_(value) {};
void execute()
{
cout << value_ << endl;
}
private:
T value_;
};
int main()
{
auto printer1 = Printer<int>(100);
auto printer2 = Printer<double>(123.4);
auto printer3 = Printer<string>("hello world!");
printer1.execute();
printer2.execute();
printer3.execute();
system("pause");
}
定义在类模板之外的成员函数必须以关键字template开始，后接类模板参数列表。
template<typename T>
void Printer<T>::execute2()
{
std::cout << value_ << std::endl;
}
成员函数只有在被用到才会实例化，这一特性使得即使类型不能完全符合类模板要求，我们仍然能用该类型实例化类。下面代码中的printer1虽然不能调用execute()，但是仍然可以实例化并调用其它成员函数。
template<typename T>
class Printer
{
public:
Printer<T>(T value):value_(value) {};
void execute()
{
cout << value_ << endl;
}
void printAddress()
{
cout << &value_ << endl;
}
private:
T value_;
};
int main()
{
auto printer1 = Printer<vector<int>>({1,2,3});
//printer1.execute();
printer1.printAddress();
system("pause");
}
在类模板自己的作用域中，我们可以直接使用模板名而省略尖括号。
template<typename T>
class Printer
{
public:
Printer<T>(T value):value_(value) {};
void execute()
{
cout << value_ << endl;
}
Printer& getSelf() { return *this; };
Printer<T>& getSelf2() { return *this; };
Printer& getSelf3();
private:
T value_;
};
//类模板外使用类模板名
template<typename T>
Printer<T>& Printer<T>::getSelf3()
{
Printer& printer = *this;
return printer;
}
int main()
{
auto printer1 = Printer<int>(100);
printer1.getSelf().execute();
printer1.getSelf2().execute();
printer1.getSelf3().execute();
system("pause");
}
类模板的每个实例都有一个独立的静态成员，类似其它成员函数，一个静态成员函数只有在使用时才会实例化。
template<typename T>
class Printer
{
public:
static int testValue_;
};
template<typename T>
int Printer<T>::testValue_ = 0;
int main()
{
Printer<double>::testValue_ = 100;
Printer<int>::testValue_ = 101;
cout << Printer<double>::testValue_ << endl;
cout << Printer<int>::testValue_ << endl;
system("pause");
}
非类型模板参数
除了定义类型参数，还可以在模板中定义非类型参数，一个非类型参数表示一个值而非一个类型，我们通过特定的类型名而不是typename来指定非类型模板参数。
非类型模板参数可以是一个整型，或者是一个指向对象或函数类型的指针或引用，非类型模板参数的模板实参必须是常量表达式，从而允许编译器在编译时实例化模板。
template<int N,int M>
int compare(const char (&value1)[N], const char(&value2)[M])
{
return strcmp(value1,value2);
}
int main()
{
cout << compare("11", "112") << endl;
system("pause");
}
默认模板实参
就像我们能为函数参数提供默认参数意义，我们也可以为函数和类模板提供默认实参：
template<typename T,typename F=less<int>>
bool compare(const T & value1, const T & value2, F func = F())
{
return func(value1, value2);
}
template<typename T=int>
class MyClass {
public:
T value = {};
};
int main()
{
//使用默认模板实参
compare(111, 2222);
compare(string("111"), string("2222"), less<string>());
//使用默认模板实参
MyClass<> value1;
MyClass<double> value2;
value2.value = 3.1416;
cout << value1.value << endl;
cout << value2.value << endl;
system("pause");
}
限制模板参数
C++不像其它语言能显式限制模板参数，例如Java里的extends，Swift里的T:ClassB，好处是我们可以把要使用的成员先写好，模板实例化的时候编译器会判断该类型是否符合条件，不符合则编译失败。
template<typename T>
size_t getSize(const T & value)
{
return value.size();
}
class MyClass {
public:
size_t size() const { return 3; }
};
int main()
{
vector<int> value1 = { 1,2,3,4,5 };
MyClass value2;
int value3;
cout <<getSize(value1)<< endl;
cout << getSize(value2) << endl;
cout << getSize(value3) << endl;//错误，int没有size方法
system("pause");
}
控制模板实例化
当多个源文件使用了相同的模板，并提供相同的模板参数时，每个文件都会有该模板的一个实例，为了避免这种额外开销，我们可以使用显式实例化，当编译器遇到extern template时不会在本文件中生成实例化代码，而是从定义处实例化代码，可能有多个extern声明但是只能有一处定义。和普通实例化不同，实例化定义会初始化所有成员，即使我们没有使用该成员。
Example.h
template<typename T>
class MyClass {
public:
//int getSize() { return value.size(); };
T value = {};
};
Example.cpp
#include "Example.h"
//定义MyClass<int>
template class MyClass<int>;
main.cpp
//声明MyClass<int>
extern template class MyClass<int>;
int main()
{
MyClass<int> value;
cout << value.value << endl;
system("pause");
}
指定显式模板实参
函数模板一般会推断模板参数类型，但有时候也需要指定显式模板实参，可以只指定前面的一部分实参，后面的可以让编译器推断。
template <typename T1,typename T2,typename T3>
T1 getResult(T2 value1, T3 value2)
{
return value1+value2;
}
int main()
{
cout <<getResult<int>(1,2)<< endl;
cout << getResult<int>(1.0, 2.2) << endl;
cout << getResult<string>(string("hello "), string("world!")) << endl;
system("pause");
}
重载与模板
当有多个重载模板对一个调用提供同样好的匹配时，编译器会选择最特例化的版本，越通用的模板的优先级越低。
对于一个调用，如果一个非函数模板与一个函数模板提供同样好的匹配，则选择非模板版本。
