函数模板与类模板（模板类）

什么是泛型编程？

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

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

下面我们就来说说函数模板：

函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的类型版本

格式：

template<typename T1,typename T2......typename Tn>

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

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

typename是函数模板的关键字，也可以用class代替（但是一定不能用struct代替）

 

当然你可以不止定义一个参数，你可以定义多个参数：

//template<class T1,class T2>
//T1 Add( T1 left,  T2 right)
//{
//	return left + right;
//}
//int main()
//{
//	int a1 = 10, a2 = 20;
//	double b1 = 10.1, b2 = 9.9;
//	cout<<Add(a1, a2);
//	cout<<Add(b1, b2);
//	cout << Add(a1, (int)b1);
//	return 0;
//}

 

当然说到这里就不得不说说关于函数模板的实例化：

函数模板的实例化分为显式实例化和隐式实例化，就是让不同类型的参数去转化成同一类型去进行运算

上面那个代码“cout<<Add(a1,(int)b1)”,就是将b1的类型转化为int进行运算，这就是隐式实例化

而显式实例化就是下面这个代码

 

{
	int a = 10;
	double b = 2.3;
	cout<<Add<int>(a, b)<<endl;
	return 0;
}*

 

参数的匹配规则：

1.同名的非模板函数和一个函数模板,而且这个函数模板还可以被实例化为这个非模板函数；

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 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.模板函数不允许自动类型转化，但是一般函数可以。

那么还是让我们来看代码吧。

#include<iostream>
using namespace std;
//template<class T1,class T2>
//T1 Add( T1 left,  T2 right)
//{
//	return left + right;
//}
//int main()
//{
//	int a1 = 10, a2 = 20;
//	double b1 = 10.1, b2 = 9.9;
//	cout<<Add(a1, a2);
//	cout<<Add(b1, b2);
//	cout << Add(a1, (int)b1);
//	return 0;
//}隐式类型转化
/*int main()
{
	int a = 10;
	double b = 2.3;
	cout<<Add<int>(a, b)<<endl;
	return 0;
}*///显示类型转化
//int Add(int left, int right)
//{
//	return left + right;
//}
//void test()
//{
//	cout<<Add(1, 2)<<endl;
//	cout<<Add(1, 5.0)<<endl;
//}
//int main()
//{
//	test();
//	return 0;
//}

你可以调试去探究到底哪个参数调用nage函数。

类模板：类模板的格式

template<class T1,class T2....classTn>

class 类模板名

{

     类成员

}；

 

让我们来看下代码，更好理解；

template<class T>
class Time
{
public:
	Time(T hour = 10, T minute = 20, T sec = 10)
		:_hour(hour)
		, _minute(minute)
		, _sec(sec)
	{}
	~Time()
	{
		cout << "~Time" << endl;
	};
	void diaplay();
private:
	T _hour;
	T _minute;
	T _sec;
};

template<class T>
void Time<T>::diaplay()
{
	cout << _hour << ":" << _minute << ":" << _sec << endl;
}
int main()
{
	Time <int>t1(20,10);
	t1.diaplay();
	return 0;
}

 注意：类模板函数放在类外定义时，一定要加模板参数列表。

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

Vector<int> s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
Vector<double> s2;
s2.PushBack(1.0);
s2.PushBack(2.0);
s2.PushBack(3.0);
for(size_t i = 0; i < s1.Size(); ++i)
{
 cout<<s1[i]<<" ";
}
cout<<endl;
for(size_t i = 0; i < s2.Size(); ++i)
{
 cout<<s2[i]<<" ";
}
cout<<endl;

模板类是类模板实例化后的结果：举个简单例子 类模板相当于一个做饼干的模板，你可以用这个模板做出饼干，然而至于做出来是什么味道，就要看你用什么东西去实例化，你可以奶油，也可以用巧克力。这些东西不同虽然做出来都是饼干但是味道不同。