C++ 模板（一）

泛型编程：

一.什么是泛型编程？？
泛型编程（Generic Programming）是一种语言机制，通过它可以实现一个标准的容器库。
像类一样，泛型也是一种抽象数据类型，但是泛型不属于面向对象，它是面向对象的补充和发展。
二.泛型编程的实例：
比如：实现一个函数的交换：
我们可以通过函数重载实现：

 void swap(int& a,int& b){
    int tmp=a;
    a=b;
    b=tmp;
 }

 void swap(double& a,double& b){
   int tmp=a;
   a=b;
   b=tmp;
 }

使用函数重载虽然可以实现，但是还是比较麻烦：
1.重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型的出现，就需要增加对应的函数；
2.代码的维护性比较低，一个出错可能所有的重载均出错；

因此可以通过一个模板来实现所有的类型：

 template <typename T>
 void Swap(T& a, T& b)
 {
     T temp;
     temp = a;
     a = b;
     b = temp;
 }
 

泛型编程可以用来实现一个标准的容器库；编写与类型无关的通用代码，是代码复用的一种手段；模板是泛型编程的基础；

函数模板：

一.函数模板的概念：
函数模板代表了一个函数家族；该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

二.函数模板格式：

template<typename T1, typename T2,…,typename Tn> 返回值类型 函数名(参数列表){}

举例：

 template<typename T>
 void swap(T& left,T& right){
    T tmp=left;
    left=right;
    right=tmp;
 }

template关键字用于声明开始进行泛型编程；typename关键字用于声明泛指类型（也可使用class）；

三.函数模板的实例化：
1.隐式实例化：让编辑器根据实参推演模板参数的实际类型；

 #include <iostream>
 #include <stdlib.h>
 using namespace std;

 template<typename T>
 T Add(T& left, T& right){
	 return left + right;
 }

 int main(){
	 int a1 = 10;
	 int a2 = 20;

	 double b1 = 10.1;
	 double b2 = 20.1;

	 cout<<Add(a1, a2)<<endl;
	 cout<<Add(b1, b2)<<endl;

   //当输出为：cout<<Add(a1,b1)<<endl时，该语句不能通过编译；
   //因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参b1将T推演为double类型，
   //但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错；

    // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化 
     cout<<Add(a1,(int)b1)<<endl;      //输出结果为11；
	 system("pause");
	 return 0;
 }
 

输出结果为：

2.显示实例化：在函数名后的<>中指定模板参数的实际类型；

 int main(){
    int a=10;
    double b=20.1;
   
   //显示实例化：
    cout<<Add<int>(a,b)<<endl;
    return 0;
 }

 //输出结果为：30；

四.模板参数的匹配原则：
1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数；

 #include <iostream>
 #include <stdlib.h>
 using namespace std;

 //专门处理int的加法函数；
 int Add(int a, int b){
	 return a + b;
 }

 //通用加法函数；
 template<typename T>
 T Add(T& left, T& right){
	 return left + right;
 }
 int main(){
	 int a1 = 10;
	 int a2 = 20;
	 cout << Add(a1, a2) << endl;   //与非模板函数匹配，编译器不需要特化；
	
	 double b1 = 10.1;
	 double b2 = 20.1;
	 cout<<Add<int>(a1,b1)<<endl;   //调用编译器特化的函数；
	 system("pause");
	 return 0;
 }

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函数 
 }    
 

3.模板函数不允许自动类型转换，但普通函数可以进行自动类型转换；

类模板：

一.类模板的格式与定义：

template<class T1, class T2, ..., class Tn> 
class 类模板名 {    
   // 类内成员定义
}

C++中的类模板，规则与函数模板基本相同，只是调用时只能显示指定具体类型，编译器无法自动推导，下边直接以例子来展示;

 #include <iosteam>
 using namespace std;
 template<typename T>
 class complex{
 public:
    //构造函数：
    Complex(T a, T b)
     {
         this->a = a;
         this->b = b;
     }
   
    //运算符重载：
    Complex<T> operator+(Complex &c)
     {
         Complex<T> tmp(this->a+c.a, this->b+c.b);
         return tmp;
     }
 private:
     T a;
     T b;
 }

 int main()
 {
    //对象的定义，必须声明模板类型，因为要分配内容；
     Complex<int> a(10,20);  
     Complex<int> b(20,30);
     Complex<int> c = a + b;

     return 0；
  }
  
   

类模板实例化：
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类；

类模板非常适用于编写数据结构相关的代码