初始c++ 中的模板

泛型编程

定义：编写与类型无关的通用代码，是代码复用的一种手段。模板也是范型编程的一种

当我们没有学习泛型编程之前，如果我们需要实现一个通用类型的交换函数，可以使用函数重载的方法

代码如下：

#include<iostream>
using namespace std;
void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
void Swap(float& x, float& y)
{
	float tmp = x;
	x = y;
	y = tmp;
}
void Swap(char& x, char& y)
{
	char tmp = x;
	x = y;
	y = tmp;
}
void Swap(double& x, double& y)
{
	double tmp = x;
	x = y;
	y = tmp;
}
//等等
int main()
{
	
		int a = 2;
		int b = 3;
		cout << a << "   " << b << endl;
		
		Swap(a, b);
		cout << a << "   " << b << endl;
	
		char ch = 'A';		
	    char ch1 = 'B';
		cout << ch << "   " << ch1 << endl;
	
		Swap(ch, ch1);
		cout << ch << "   " << ch1 << endl;
		
		
		double c = 2.22;
		double d = 3.333;
		cout << c << "   " << d << endl;
		
		Swap(c, d);
			
		cout << c <<"   "<< d << endl;
		

}

结果如下：

但是函数重载有如下的缺点：

重载的函数仅仅只是函数类型不同，代码的复用率比较低，只要有新类型出现时，就要增加对应类型的函数

代码的维护率低，一个出错，可能所有的重载的都出错。

模板

但是学习了函数模板之后，实现起来就比较方便

模板分为：函数模板和类模板

1、函数模板

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

函数模板格式    template<typename T1,typename T2,.......,typename Tn>

                         返回值类型  函数名 （形参列表）{}

我们可以使用函数模板实现全类型的交换函数

代码如下：

#include<iostream>
using namespace std;
template<class T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	
		int a = 2;
		int b = 3;
		cout << a << "   " << b << endl;
		
		Swap(a, b);
		cout << a << "   " << b << endl;
	
		char ch = 'A';		
	    char ch1 = 'B';
		cout << ch << "   " << ch1 << endl;
	
		Swap(ch, ch1);
		cout << ch << "   " << ch1 << endl;
		
		
		double c = 2.22;
		double d = 3.333;
		cout << c << "   " << d << endl;
		
		Swap(c, d);
			
		cout << c <<"   "<< d << endl;
		

}

只需要写一个模板就可以实现，运行结果如下：

函数模板的原理：函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具，其实模板是将我们应该做的重复的事情交给编译器。

对于编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供使用。

函数模板的实例化：

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为隐式实例化和显示实例化

（1）、隐式实例化：让编译器根据实参推演模板参数的实际类型

#include<iostream>
using namespace std;
template <class T>
T Add(const T& a, const T& b)
{
	return a + b;
}
int main()
{
	int a = 10, b = 20;
	double a2 = 1.123, b2 = 4.2315;
	cout<<Add(a, b)<<endl;
	cout<<Add(a2, a2)<<endl;//隐式实例化
        
	
	return 0;
}

结果如下：

但是如果我们传参数一个int 一个double 就会出错，结果如下：

这时我们需要使用显示实例化

（2）、显示实例化：函数名后的<>中指定模板参数的类型

代码如下：

#include<iostream>
using namespace std;
template <class T>
T Add(const T& a, const T& b)
{
	return a + b;
}
int main()
{
	int a = 10, b = 20;
	double a2 = 1.123, b2 = 4.2315;
	cout << Add<int>(a, a2) << endl;
	return 0;
}

结果如下：

模板参数的匹配原则

调最匹配的函数，如果有非模板函数（与函数模板同名），模板函数，他俩同时存在，且该函数模板可以推演出来非函数模板

举个例子：

#include<iostream>
using namespace std;
int Add(int x, int y)
{
	return x + y;
}
template<class T>
T Add(const T y, const T x)
{
	return x + y;
}
int main()
{
	Add(1, 2);//调非模板匹配
	Add<int >(1, 12);//调编译器特化的Add版本
}

2、类模板

定义格式：template<class T1,classT2,.......,class Tn>

                  class 类模板名

               {

                        //类内成员定义

               }；

类实例化：类模板名 <类型>

举个例子：声明一个类模板，实现两个数的比较，

#include<iostream>
using namespace std;
template <class T>//T为虚拟类型
class Compare//Compare为类模板名
{
public:
	Compare(T a=10,T b=12)//构造函数
	{
		_a = a;
		_b = b;
	}
	T max()
	{
		return (_a > _b) ? _a : _b;
	}
	T min()
	{
		return (_a < _b) ? _a : _b;
	}
private:
	T _a;
	T _b;
};
int main()
{
	Compare<int>cmp1(2, 5);//类模板的实例化:类模板名 <类型>
	cout << "max:" << cmp1.max() << endl;
	cout << "min:" << cmp1.min() << endl;


	return 0;
}

结果如下：