泛型编程
基本概念
泛型编程(Generic Programming) 指在多种数据类型上皆可操作。和面向对象编程不同，它并不要求额外的间接层来调用函数，而是使用完全一般化并可重复使用的算法，算法效率与针对某特定数据类型而设计的算法相同。
下面我们来看一个问题:如何实现一个通用的交换函数囊?
void swap(int& a, int& b) { int x = a; a = b; b = x; } void swap(char& a, char& b) { char x = a; a = b; b = a; } void swap(double& a, double& b) { double x = a; a = b; b = a; } int main() { int c = 0, d = 1; char e = 'A', f = 'b'; double a = 1.1, b = 2.2; swap(c, d); swap(e, f); swap(a, b); return 0; }
使用该函数重重载虽然可以实现，但是有几个不好的地方:
1.重载的函数仅仅只是函数类型不同,代码的复用率比较低,只要求有新类型出现时,就需要增加对应的函数
2.代码的可维护性比较低,一个出错可能所有的重载均出错那我们能否告诉编译器一个模子，让编译器根据不同对的类型利用该模子来生成代码囊?
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
函数模板
函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本.
函数模板格式
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}
typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)
template<typename T> void Swap( T& left, T& right) { T temp = left; left = right; right = temp; }
函数模板原理
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
函数模板实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
1.隐式实例化：让编译器根据实参推演模板参数的实际类型
template<class T> T Add(const T& left, const T& right) { return left + right; } int main() { int a1 = 10, a2 = 20; double d1 = 10.0, d2 = 20.0; Add(a1, a2); Add(d1, d2);
思考:Add(a1,d1)可以吗?
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
处理方式:1. 用户自己来强制转化 2. 使用显式实例化
Add(a1,(int)d1);
2. 显式实例化：在函数名后的<>中指定模板参数的实际类型
int main(void) { int a = 10; double b = 20.0; // 显式实例化 Add<int>(a, b); return 0; }
模板参数的匹配原则
1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
// 专门处理int的加法函数 int Add(int left, int right) { return left + right; } // 通用加法函数 template<class T> T Add(T left, T right) { return left + right; } void Test() { Add(1, 2); // 与非模板函数匹配，编译器不需要特化 Add<int>(1, 2); // 调用编译器特化的Add版本 }
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
// 专门处理int的加法函数 int Add(int left, int right) { return left + right; } // 通用加法函数 template<class T1, class T2> T1 Add(T1 left, T2 right) { return left + right; } void Test() { Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化 Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函 数 }
类模板
所谓类模板，实际上是建立一个通用类，其数据成员、成员函数的返回值类型和形参类型不具体指定，用一个虚拟的类型来代表。使用类模板定义对象时，系统会实参的类型来取代类模板中虚拟类型从而实现了不同类的功能。
类模板的定义格式
定义一个类模板与定义函数模板的格式类似，必须以关键字template开始，后面是尖括号括起来的模板参数，然后是类名，其格式如下：
template<class T1, class T2, ..., class Tn> class 类模板名 { // 类内成员定义 };
如建立一个用来实现求两个数最大值的类模板
#include<iostream> using namespace std; template<typename T> class Compare { public: Compare(T i, T j) { x = i; y = j; } T max() { return (x > y) ? x : y; } private: T x; T y; }; int main() { Compare<int> A(1, 2); Compare<double> B(2.1, 5.2); cout << "最大值为:" << A.max() << endl; cout << "最大值为:" << B.max() << endl; return 0; }
运行结果如下:
在以上例子中，成员函数(其中含有类型参数)是定义类体内的。但是，类模板中的成员函数，也可以在类模板外定义。此时，若成员函数中有参数类型存在，则C++有一些特殊的规定：
temlate<typename 类型参数> 函数类型 类名<类型参数>::成员函数名(形参表) ｛ 函数体； ｝ 如上题中成员函数max在类模板外定义时，应该写成： template<typename T> T Compare<T>::max() { return (x>y)?x:y; }
在类模板外定义成员函数函数举例。
template<typename T> class Compare { public: Compare(T i, T j) { x = i; y = j; } T max(); private: T x; T y; }; template<class T> T Compare<T> ::max() { return (x > y) ? x : y; }; int main() { Compare<int> A(1, 2); Compare<double> B(2.1, 5.2); cout << "最大值为:" << A.max() << endl; cout << "最大值为:" << B.max() << endl; return 0; }
类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类.
// Vector类名，Vector<int>才是类型 Vector<int> s1; Vector<double> s2;
类模板Stack的使用举例
#include<iostream.h> const int size=10; template<class T> //模板声明，其中T为类型参数 class Stack{ //类模板为Stack public: void init() { tos=0; } void push(T ob); //声明成员函数push的原型，函数参数类型为T类型 T pop(); //声明成员函数pop的原型，其返回值类型为T类型 private: T stack[size]; //数组类型为T，即是自可取任意类型 int tos; }; template<class T> //模板声明 void Stack<T>::push(T ob) //在类模板体外定义成员函数push { if(tos==size) { cout<<"Stack is full"<<endl; return; } stack[tos]=ob; tos++; } template<typename T> //模板声明 T Stack<T>::pop() //在类模板体外定义成员函数push { if(tos==0) { cout<<"Stack is empty"<<endl; return 0; } tos--; return stack[tos]; } int main() { //定义字符堆栈 Stack<char> s1; //用类模板定义对象s，此时T被char取代 s1.init(); s1.push('a'); s1.push('b'); s1.push('c'); for(int i=0;i<3;i++){cout<<"pop s1："<<s1.pop()<<endl;} //定义整型堆栈 Stack<int> s2; //用类模板定义对象s，此时T被int取代 s2.init(); s2.push(1); s2.push(3); s2.push(5); for(int i=0;i<3;i++){cout<<"pop s2："<<s2.pop()<<endl;} return 0; }
程序运行结果是：
pop s1：c pop s1：b pop s1：a pop s2：5 pop s2：3 pop s2：1
