概要
模板（针对泛型编程和STL技术，C++另一种编程思想为泛型编程，主要利用的技术就是模板）
模板特点：
（1）模板不可以直接使用，它只是个框架（参考PPT模板）；
（2）模板的通用不是万能的。
技术细节
template<typename T>
template—声明创建模板
typename—表示后面是一种数据类型，可以用class代替，比较严谨的人函数模板会用typename，类模板会用class，但class既可以表示函数模板也可以表示类模板
T—通用数据类型，名称可以替换通常为大写字母
模板使用方式一：
创建一个函数模板：
template<typename T> //声明一个函数模板告诉编译器后面代码中的T不要报错，T是一个通用数据类型 void Swap(T& a, T& b) { T tmp; tmp = a; a = b; b = tmp; } int main() { int a = 10; int b = 20; //两种方式使用函数模板 //第一种，自动推导型 Swap(a, b); //第二种，显示指定类型 Swap<int>(a, b); return 0; }
注意事项：
（1）自动类型推导：必须推导一致的数据类型T才可以使用
（2）显示指定类型：模板必须要确定T的数据类型，才可以使用
模板使用方式二：
template<class T> void fun() { cout << "没有用到T的函数模板" << endl; } int main() { fun<int>(); //就算没有用到数据类型T，但在调用函数模板时必须指定T类型 return 0; }
注意事项：
fun()函数没有用到通用数据类型，那么自动类型推导方式就用不了，只能用显示指定类型，必须要先确定T类型才能调用函数模板，就算没有用到T也要确定类型。
模板使用方式三：
普通函数和函数模板的区别：
（1）普通函数可以发生隐式类型转换；
（2）函数模板用自动类型推导，不可以发生隐式类型转换；
（3）函数模板用显示指定类型，可以发生隐式类型转换；
普通函数发生隐式类型转换：
int Add(int a, int b) { return a + b; } int main() { cout << Add(1, 2.5) << endl; //3 }
函数模板发生隐式类型转换：
template<class T> int Add(T a, T b) { return a + b; } int main() { cout << Add<int>(1, 2.5) << endl; //3 }
2.5自动转换为2
模板使用方式四：
普通函数和函数模板调用规则：
（1）如果函数模板和普通函数都可以实现，优先调用普通函数
（2）可以通过空模板参数列表来强制调用函数模板
（3）函数模板也可以发生重载
（4）如果函数模板可以产生更好的匹配，优先调用函数模板
条件（1）（3）案例：
template<class T> void Add(T a, T b) { cout << "函数模板" << endl; } //函数模板和普通函数发生重载 void Add(int a, int b) { cout << "普通函数" << endl; } int main() { Add(1, 2); //普通函数 }
条件（2）案例：
template<class T> void Add(T a, T b) { cout << "函数模板" << endl; } void Add(int a, int b) { cout << "普通函数" << endl; } int main() { Add<>(1, 2); //函数模板 }
条件（4）案例：
template<class T> void Add(T a, T b) { cout << "函数模板" << endl; } void Add(int a, int b) { cout << "普通函数" << endl; } int main() { char a = 'a'; char b = 'b'; Add(a, b); //函数模板 }
如果是普通函数还需要把char类型隐式转换为int类型，而直接调用函数模板会直接以char类型传入
当函数模板发生重载，会优先调用具体化的模板：
class Person {}; template<class T> void Compare(T& p1, T& p2) { cout << "函数模板" << endl; } //具体化模板重载 template<> void Compare(Person& p1, Person& p2) { cout << "具体化模板" << endl; } int main() { Person p1; Person p2; Compare(p1, p2); //具体化模板 }
模板使用方式五：
类模板使用：
template<class T1, class T2> class Person { public: Person(T1 name, T2 age) { this->name = name; this->age = age; } T1 name; T2 age; }; int main() { //确定类模板参数列表，string和int //不能用自动推导型，因为自动推导型需要所有参数都是同一类型 Person<string, int>("张三", 20); return 0; }
类模板和函数模板区别：
1、类模板没有自动推导的使用方式，只能用指定显示类型
2、类模板在模板参数列表中可以有默认参数
template<class T1, class T2 = int> class Person { public: Person(T1 name, T2 age) { this->name = name; this->age = age; } T1 name; T2 age; }; int main() { //确定类模板参数列表，string和int(已有默认参数) Person<string>("张三", 20); return 0; }
类模板中成员函数创建时机：
1、普通类中的成员函数一开始就可以创建
2、类模板成员函数在调用时才可以创建
class Student { public: void func() { cout << "普通成员函数" << endl; } }; template<class T1> class Person { public: T1 obj; void fun() { obj.func(); } };
编译是没问题的，为啥没有报错，不知道obj是啥，到底是对象还是其他类型，原因在于类模板成员函数在调用的时候才创建，也就是说编译的时候遇到类模板直接会忽略类模板成员函数的存在。
模板使用方式六：
类不是模板，但成员函数是模板（声明和实现都要放到头文件）
class Person { public: template<class T1> void fun(); }; template<class T1> inline void Person::fun() { }
模板使用方式七：
类模板对象作为函数参数：
（1）指定传入类型
template<class T1, class T2> class Person { public: Person(T1 name, T2 age) { this->name = name; this->age = age; } void fun() { cout << name << " " << age << endl; } T1 name; T2 age; }; //指定传入类型，string和int void func(Person<string, int>& p) { p.fun(); } int main() { Person<string, int> p("张三", 20); func(p); return 0; }
（2）参数模板化
template<class T1, class T2> class Person { public: Person(T1 name, T2 age) { this->name = name; this->age = age; } void fun() { cout << name << " " << age << endl; } T1 name; T2 age; }; //参数模板化 template<class T1, class T2> void func(Person<T1, T2>& p) { p.fun(); } int main() { Person<string, int> p("张三", 20); func(p); return 0; }
(3)整个类模板化
template<class T1, class T2> class Person { public: Person(T1 name, T2 age) { this->name = name; this->age = age; } void fun() { cout << name << " " << age << endl; } T1 name; T2 age; }; //整个类模板化 //T1为Person类型 template<class T1> void func(T1& p) { p.fun(); } int main() { Person<string, int> p("张三", 20); func(p); return 0; }
模板使用方式八：
类模板与继承：
1、当子类继承的父类是一个类模板，子类在声明的时候，要指定出父类中的T的类型
2、如果不指定，编译器无法给子类分配内存
3、如果想灵活指定出父类中的T类型，子类也需变为类模板
第一种方式不太灵活，每次继承时需要指定父类T的类型
template<class T1> class Person1 { public: T1 age; }; class student : public Person1<int> { };
第二种方式把子类变为模板，创建对象时可以指定任意类型，主推！
template<class T1> class Person1 { public: T1 age; }; template<class T, class T1> class student : public Person1<T1> { public: T name; }; int main() { //相当于父类的T定义为int类型，子类的T定义为string类型 student<string, int> p; return 0; }
模板使用方式九：
类模板成员函数类外实现：
template<class T1> class Person2 { public: Person2(T1 age); void fun(T1 a); T1 age; }; template<class T1> Person2<T1>::Person2(T1 age) { this->age = age; } template<class T1> void Person2<T1>::fun(T1 a) { cout << a << endl; } int main() { Person2<int> p(50); p.fun(3); return 0; }
类模板使用方式十：
类模板和友元 ：
1、全局函数类内实现
template<class T1, class T2> class Person { //全局函数做友元，并在类内实现 friend void fun(Person<T1, T2>& p) { cout << p.name << " " << p.age << endl; } public: Person(T1 name, T2 age) { this->name = name; this->age = age; } T1 name; T2 age; }; int main() { Person<string, int> p("张三", 20); fun(p); return 0; }
2、全局函数类外实现
template<class T1, class T2> class Person; template<class T1, class T2> void fun(Person<T1, T2>& p) { cout << p.name << " " << p.age << endl; } template<class T1, class T2> class Person { friend void fun<>(Person<T1, T2>& p); public: Person(T1 name, T2 age) { this->name = name; this->age = age; } T1 name; T2 age; }; int main() { Person<string, int> p("张三", 20); fun(p); return 0; }
全局函数类外实现
（1）声明友元的时候需要加空模板参数列表；
（2）因为在Person中声明了fun函数，故需要提前让Person知道这个函数的存在，所以需要把函数模板放在Person类的前面；
（3）由于函数模板的实现在Person类的前面，同时函数的传入参数中引入了Person类模板，编译器不知道Person的存在，所以要在函数实现前面声明下Person类模板，提前让fun函数知道传入的参数是存在的。
小结
类模板分文件编写：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时调用不到。
解决办法：
1、直接包含.cpp文件（很少用）
2、将声明和实现写在同一个文件中，并更改后缀名为.hpp，hpp是约定的名称并不是强制，以后一看到hpp的文件就知道该文件存放的是类模板
