12.模板

1.定义

模板就是做好的一个样式，用户直接去套用就可以快
速实现功能。
模板是不能够直接使用，必须要实例化才能用。

2.作用

提高代码的复用性

例如：现在要求同学们编写一个 jiaohuan 交换函数，
实现 （字符型，整形，浮点型，字符串类型，的数据交
换） 实现上述功能函数 。

开发人员就发现，这个函数的功能和参数个数，都是
一样的。只是类不一样。那么能否设计一个通用类型出来？？ -》 函数模板！！

3.函数模板

拥有一个通用类型的函数。

3.1.通用类型的定义语法

template<typename 通用类型> 或 template<class 通用类型>

//例子：声明一个带有通用类型的函数 
template<class T> 
void show(T a) 
{
} //声明了一个模板函数，带有一个通用类型T 

T 的类型，系统会自动根据用户传入的参数来推导出他的 类型。

模板函数的设计案例：

template <class T> 
void jiaohuan(T &a,T &b) 
{ 
	T c = a; 
	a = b; 
	b = c; 
}

int main() 
{ 
	int a=10,b=20; 
	jiaohuan(a,b); 
	cout << a << ":" << b << endl; 

	float a1=3.14,b1=4.44; 
	jiaohuan(a1,b1); 
	cout << a1 << ":" << b1 << endl;
	
	string a2="hello",b2 ="world"; 
	jiaohuan(a2,b2); 
	cout << a2 << ":" << b2 << endl; 
}

总结：模板最重要的特点就是会自动推导数据的类型！！！

• 模板函数与普通函数区别：

  1. 普通函数调用，可以发生自动类型转换。（自动类型转换 从精度低的数据 往 精度高的数据进行转换 char -> short -> int -> float -> double ）
  2. 模板函数调用，没有自动类型转换，只会发生自动类型推导。

  template <class  T>  //定义了一个通用类型T  
  T add(T a,T b)
  {
      return a+b;
  }
  
  int main()
  {
  	 int a=10;
       short b=20; 
       cout << add(a,b) << endl;
       // add(a,b)  发生自动类型推导  -》 第一次推导，T=int  ，第二推导  T=short 
       // 无法确定 通用类型  T 是哪一种类型，所以就无调用该模板。 
   }
  

  解决方式：

  1. 限定模板的T 的数据类型。
        add<int>(a,b)   -》 把通用类型T 设置为 int ,系统就不需进行自动推导
      
  2. 再定义一个通用类型，让函数推导成功  
  //定义一个模板函数，拥有两个通用类型 
  template <class  T,class T1>
  T add(T  a,T1 b)
  {
      return a+b;
  }
      
  //成功发生推导    add(T,T1)  ->  add(int,short)
  

• 模板函数与普通函数的调用规则

  1. 当模板函数 与 普通函数 实现的功能相同时，优先调用普通函数。
  2. 假设用户不想调用普通函数，那么怎么做？？ 利用 <> 指定是用模板。
  3. 当模板函数比普通函数，更好匹配参数时，那么编译器，就会优先调用模板函数。（c++的编译器是很智能的！！）
  4. 模板函数也支持重载。

3.2. 模板函数的局限性

对于用户自定义的数据类型，模板函数是无法对数据进行操作的。
如果模板函数出现了局限性，那么就特殊情况特殊处理！！

#include <iostream>

using namespace std; 

class  base
{
public:  
     base(int a):a(a){}
private:
int a;
//friend  bool   big(base a,base b);
friend  bool   operator>(base a,base b);
};

//重载 base 的比较运算符 
bool operator>(base a,base b)
{
   if(a.a > b.a)
    {
        return true;
    }else
    {
        return false;
    }
}

//设计一个比较两个数据大小的模板 
template <class T>
bool   big(T a,T b)
{
    if(a > b)
    {
        return true;
    }else
    {
        return false;
    }
}

/*
//特殊数据进行特殊处理 
bool   big(base a,base b) 
{

    if(a.a > b.a)
    {
        return true;
    }else
    {
        return false;
    }
}
*/

int main()
{

    base a=100,b=20;
    if(big(a,b))
    {
        cout  << "a > b"  << endl;
    }else
    {
        cout << " a <= b"  << endl;
    }
}

练习：设计一个模板函数，可以返回三个数据中的最大一个。 对于自定义数据类型也能处理。 

4. 模板类

4.1.定义

当一个类中拥有一个通用的数据类型，那么这个类就是一个模板类，模板类在没实例化前，不能定义对象。

4.2.语法

template <class 通用类型>
class  类名 
{
    通用类型 变量名
}; 
-------------------------------------------
例子：  
template <class T>
class  base
{
    T a;
}; //-> 这就是一个模板类

模板类没有自动类型推导功能，必须要用户手动实例化
例子：

//设计一个模板类
template <class T>
class  base
{
	public: 
	base(T  a):a(a){}  
	private: 
	T a;
};

int main()
{
      int date=10086;
      base<int> a(date);  //实例化模板类型！！！！ 
}

//练习： 设计一个模板类，里面拥有两个通用类型 T   和  T1 。  在定义该模板类的对象。 

• 模板函数与模板类的区别
  1. 模板类没有 自动类型推导功能，模板函数有
  2. 模板类可以使用默认类型
     模板的默认类型使用

  template <class T=int>
  class  base
  {
  public: 
      base(T a):a(a){}
      void show()
      {
          cout << a << endl;
      }
  private:
  T a;
  };
  
  int main()
  {
      base<>  a(3.1415126); //不写类型，则使用上面的默认类型 ,就算添加了默认类型 <> 也是需要填写了
                              //区分该类是一个模板类 
      a.show();
      base<double>  b(3.1415126);  //使用用户指定的模板参数 
      b.show();
      
  }
  

4.3.模板类作为函数的参数传递

注意： 当一个模板类，作为函数的参数时，无法直接通过类名作为函数的参数传递！！
解决方法：

1.在函数的参数列表中，指定模板的类型。   
     void show_base(base<int> a)  
   
2.继续把类 参数类型模板化  
template <class T>
void show_base1(base<T> a)
   
3.直接把该函数设计为一个 纯模板函数  
  template <class T>
void show_base2(T a) 

设计案例：

#include <iostream>
using  namespace std;

//这是一个模板类 
template <class T>
class  base{
public: 
base(T a):a(a){}
T a; 
};

class  base1
{
public: 
base1(int a):a(a){}
int a; 
};


//1.指定模板类的参数列表，进行传递
void show_base(base<int> a)
{
    cout <<   a.a << endl;
}

//2.继续把类型模板化 
template <class T>
void show_base1(base<T> a)    //模板函数-》 自动类型推导功能
{
    cout <<   a.a << endl;
}

//3.把该函数设计为模板函数
template <class T>
void show_base2(T a) 
{
     cout << a.a << endl;
}

int main()
{

     base<int>  a(10086); 
      //调用函数 
      show_base(a); 
      show_base1(a);
      show_base2(a);
}

总结： 推荐使用 第一种方法！！

4.4. 模板类的成员函数类外编写

#include <iostream>

using  namespace std; 

//定义一个模板类 
template <class T>
class base
{
   public:
    //单纯的声明接口
    base(T a); 
   ~base(); 
   void show(); 

private: 
T a;
};

//类外实现这些接口 
template <class T>
base<T>::base(T a)
{
    this->a = a;
}

template <class T>
base<T>::~base()
{
   cout << " base析构函数" << endl;
}

template <class T>
void base<T>::show()
{
    cout << this->a << endl;
}

int main()
{

   base<int>  a(10086); 
   a.show();
}