C++另一种编程思想称为泛型编程，主要利用的技术是模板
C++提供两种模板机制：函数模板和类模板
C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，
其类内部的类型和函数的形参类型不具体指定， 用一个虚拟的类型来代表。
这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。
即：我们提供一个抽象的函数或类，并不具体指定其中数据的类型，而是某个虚拟类型代替。只提供基本的功能。其具体的数据类型，只在其被调用时视具体情况实例化。
函数模板
举个例子
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T1,typename T2> //模板函数声明与定义
T2 test(T1 tmp, T2 tmp1) {
T2 tmp2 = tmp + tmp1;
return tmp2;
}
int main(void) {
cout << "test(10, 5)=" << test(10, 5) << endl; //调用模板函数，模板函数通过传入的参数自动推导未实例化的类型
cout << "test(5,'A')=" << test(5,'A') << endl;
cout << "test(10.5, 5.5) =" << test(10.5, 5.5) << endl;
system("pause");
return 0;
}
函数模板的声明通过关键字template与typename 实现。其中，template告知编译器这是函数模板的声明，typename用来声明虚拟类型。比如你要声明一个模板函数，里面需要两个不同的变量，那么你就需要通过typename声明两个不同的虚拟类型T1，T2。
声明好后，你就可以在函数定义中使用虚拟类型来定义变量，但是要注意，用同一个虚拟类型定义的变量就只能是同种类型，比如用T1定义的变量只能是同种变量，可以是int,也可以是char。这取决于其实例化时被实例化为哪种类型。
C++函数模板注意事项
注意事项：
1、自动类型推导，必须推导出一致的数据类型T，才可以使用
2、模板必须要确定出T的数据类型，才可以使用
cpp
using namespace std;
template<class T>
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 10;
int b = 20;
char c = 'c';
//1、自动类型推导，必须推导出一致的数据类型T，才可以使用
mySwap(a, b);
//mySwap(a, c);推导不出一致的T类型
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
template<class T>
void func()
{
cout << "func()的调用" << endl;
}
void test02()
{
//2、模板必须要确定出T的数据类型，才可以使用
func<int>();
}
int main() {
test01();
test02();
return 0;
}模板函数的调用
1）显式类型调用
可以显式的调用模板函数，即在调用时人为地指明虚拟类型的具体类型。
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T1,typename T2> //模板函数声明与定义
T2 test(T1 tmp, T2 tmp1) {
T2 tmp2 = tmp + tmp1;
return tmp2;
}
int main(void) {
cout << "test(5,'A')=" << test<int,char>(5, 'A') << endl; //<int,char>显式的指明模板的类型
system("pause");
return 0;
}2）自动推导
即不指明具体的数据类型，而让编译器根据传入的数据自动推导出数据类型。
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T1,typename T2> //模板函数声明与定义
T2 test(T1 tmp, T2 tmp1) {
T2 tmp2 = tmp + tmp1;
return tmp2;
}
int main(void) {
cout << "test(5,'A')=" << test(5, 'A') << endl; //自动推导数据类型
system("pause");
return 0;
}模板函数与函数重载
熟悉函数重载的人应该会好奇，如果既有模板函数又有同名的普通函数，而且参数列表的参数个数是一样的，那么在主函数中调用同名函数，编译器具体会调用哪一个呢？
下面看一个例子：
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T1,typename T2> //模板函数声明与定义
T1 test(T1 tmp, T2 tmp1) {
cout << "调用模板函数！" << endl;
return (tmp + tmp1);
}
int test(int tmp, int tmp1) { //重载的普通函数
cout << "调用普通函数！" << endl;
return 0;
}
int main(void) {
char tmp = 'c';
int tmp1 = 0;
int a = 5;
cout << "test(5,'c')=" << test(a, tmp) << endl;
cout << "test(5,0)=" << test(a, tmp1) << endl;
system("pause");
return 0;
}
普通函数的两个参数都是int型，在第一次调用test时第二个参数使用的是char型，调用的是模板函数，第二次使用的是int型，调用的是普通函数。
这是为什么呢？理论上来说，模板函数两个都能匹配，使用。而普通函数也能匹配这两次调用的参数（在C语言中，char型变量是可以作为int型参数使用的）。
这是因为模板函数可以自动推导类型，在第一次调用中，两个类型分别被推导为int型与char型。而普通函数是两个int型，虽然也能使用传入的参数，但模板函数明显能更好的匹配参数列表。
也就是说，如果模板函数实例化后的类型能更好的匹配参数列表的话就使用模板函数。
那么当这两个函数都能完全匹配参数列表的时候呢？通过第二次test的调用结果不难发现，这时候，编译器会调用普通函数。
如果一定要使用模板函数，可以使用<>显式的指定使用模板函数。看下面的例子。
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T1,typename T2> //模板函数声明与定义
T1 test(T1 tmp, T2 tmp1) {
cout << "调用模板函数！" << endl;
return (tmp + tmp1);
}
int test(int tmp, int tmp1) { //重载的普通函数
cout << "调用普通函数！" << endl;
return 0;
}
int main(void) {
char tmp = 'c';
int tmp1 = 0;
int a = 5;
cout << "test(5,'A')=" << test(a, tmp) << endl;
cout << "test<>(5,0)=" << test<>(a, tmp1) << endl; //使用<>显式的调用模板函数
system("pause");
return 0;
}
类模板
类模板是为了减少重复工作量而出现的一种进制，当一个类的功能类似只是类型不同时，一个通用的类模板可以根据使用者的需要而生成具体类型的类，从而减少功能重复的代码。
类模板作用：建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表
解释：
template--声明创建模板
typename--表明其后面的符号是一种数据类型，可以用class代替
T--通用的数据类型，名称可以替换，通常为大写字母
在类内部定义与声明
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T>
class DEMO {
public:
DEMO(T data) {
this->data = data;
}
~DEMO() {
}
int GetData() {
return this->data;
}
private:
T data;
};
template <typename T,typename T1>
class DEMO1 {
public:
DEMO1() {
}
~DEMO1();
private:
T data;
T1 ch;
};
int main(void) {
DEMO<int> demo(5); //显示的指定类型为int
DEMO1<int, char> demo1(); //显示的指定类型分别为int,char
cout << "data=" << demo.GetData() << endl;
system("pause");
return 0;
}类模板的定义与使用使用的是和模板函数一样的关键字。即先声明template,在使用typename声明虚拟类型。
与模板函数不同的是，类模板不能被自动推导出类型，只能显示的指定具体的类型。如上面代码中的 DEMO< int > demo(5)，该模板类被显示的指定为int型。
在类外部定义成员函数
在类内部声明成员函数，在类外部定义成员函数时，只要成员函数参数列表中出现了类限定域说明，模板类作为返回类型，模板类作为参数类型，那么就要在成员函数之前声明 template <类型形式参数表>，并且在模板类后加上虚拟参数列表。
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T>
class DEMO {
public:
DEMO(T data);
~DEMO();
DEMO operator+(int sum);
int PrintData(DEMO& demo);
private:
T data;
};
template<typename T> //出现了类限定域说明
DEMO<T>::DEMO(T data)
{
this->data = data;
}
template<typename T> //出现了类限定域说明
DEMO<T>::~DEMO()
{
}
template<typename T> //出现了作为返回值类型的模板类类型
DEMO<T> DEMO<T>::operator+(int sum)
{
return *this;
}
template<typename T> //出现了作为参数类型的模板类类型
int DEMO<T>::PrintData(DEMO<T>& demo)
{
cout << "data=" << demo.data << endl;
return 0;
}
int main(void) {
DEMO<int> demo(5), demo1(15);
demo.PrintData(demo1);
demo + 5;
system("pause");
return 0;
}
DEMO< T >中的< T >是虚拟参数列表。
总结来说，只要看到了模板类的类名关键字出现在成员函数参数列表中，就要在成员函数之前声明 template <类型形式参数表>，并且在模板类类名后加上虚拟参数列表。
模板类的继承
分为三种情况。一：子类是模板类，父类是普通类；二：父类是模板类，子类是普通类；三：父类与子类都是模板类。其中第一种情况与两个普通类的继承是一样的。就不说了。
1）父类是模板类，子类是普通类：
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T>
class FATHER {
public:
FATHER(T data) {
this->data = data;
}
~FATHER() {
}
private:
T data;
};
class SON:public FATHER<int> { //显示的指明父类的具体类型
public:
SON(int data):FATHER<int>(data) {
this->data = data;
}
~SON() {
}
int GetData() {
return data;
}
private:
int data;
};
int main(void) {
SON son(15);
cout << "data=" << son.GetData() << endl;
system("pause");
return 0;
}子类是一般类，父类是模板类,继承时必须在子类里实例化父类的类型参数。其实这很好理解，因为在子类对象构造之前，会先调用父类的构造函数，父类为模板类，要想实例化，需要有指定的类型。
2）父类与子类都是模板类：
cpp
#include <iostream>
#include <stdio.h>
using namespace std;
template <typename T>
class FATHER {
public:
FATHER(T data) {
this->data = data;
}
~FATHER() {
}
private:
T data;
};
template <typename T1>
class SON:public FATHER<T1> { //使用子类的模板类型传递到父类中，也可以使用具体的类型
public:
SON(int data):FATHER<int>(data) {
this->data = data;
}
~SON() {
}
int GetData() {
return data;
}
private:
T1 data;
};
int main(void) {
SON<int> son(15);
cout << "data=" << son.GetData() << endl;
system("pause");
return 0;
}当子类与父类都是模板类时，继承时也必须在子类里实例化父类的类型参数，值得注意的是，此时实例化的类型参数可以使用子类的模板类型。即让父类与子类在实例化后拥有一样的具体类型。当然也可以使用其它的具体类型。