C++笔记 11（函数模板）

一. 模板

1. 模板的概念

模板就是建立通用的模具，大大提高复用性

模板的特点：
1）模板不可以直接使用，它只是一个框架
2）模板的通用并不是万能的

2. 函数模板

C++的另一种编程思想称为“泛型编程”，主要利用的技术就是模板。
C++提供两种模板机制：函数模板和类模板。

2.1 函数模板语法

作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟类型来代表。

语法：template <typename T> 函数声明或定义

template — 声明创建模板；
typename — 表明其后面的符号是一种数据类型，可以用class代替；
T — 通用的数据类型，名称可以替换，通常为大写字母

//交换整型函数
void swapInt(int &a ,int &b)
{
	int temp=a;
	a=b;
	b=temp;
}

//交换浮点型函数
void swapDouble (double &a ,double &b)
{
	double temp=a;
	a=b;
	b=temp;
}

//利用模板提供通用的交换函数
template<typename T>
void myswap(T &a ,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}

void test()
{
	int a=10;
	int b=20;
	
	//利用模板实现交换
	//1.自动类型推导
	myswap(a,b);
	
	//2.显示指定类型
	myswap<int>(a,b);
	cout<<....<<endl;
}

int main(){...}

总结：
1）函数模板利用关键字 template
2) 使用函数模板有两种方式：自动类型推导、显示指定类型
3) 模板的目的是为了提高复用性，将类型参数化

2.2 函数模板注意事项

1）自动类型推导，必须推导出一致的数据类型T，才可以使用；
2）模板必须确定出T的数据类型，才可以使用

//利用模板提供通用的交换函数
template<class T>
void myswap(T &a ,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}

//1.自动类型推导，必须推导出一致的数据类型T，才可以使用
void test01()
{
	int a=10;
	int b=10;
	char c ='c';
	myswap(a,b); //正确，可以推导出一致T
	myswap(a,c); //错误，推到不出一致的T类型
}

template <class T>
void func()
{
	cout<<"func调用"<<endl;
}

void teTst02()
{
	//func(); 错误，模板不能独立使用，必须确定出T的类型
	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
}

int main()
{... ...}

2.3 函数模板案例

案例描述：利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序，排序规则从大到小，排序算法为选择排序，分别利用char 数组和int 数组进行测试。

template <typename T>
void mysort (T arr[] ,int len)
{
	for(int i=0;i<len;i++)
	{
		int max =i; //认定最大值的下标
		for(int j=i+1;j<len;j++)
		{
			/*认定的最大值比遍历出的数值要小，
					说明j下标的元素才是真正的最大值*/
			if(arr[max]<arr[j])
			{
				max=j ; //更新最大值下标
			}
		}
		if(max!=i) //如果最大数的下标不是i,交换两者
		{
			myswap(arr[max],arr[i]);
		}
	}
}

template<class T>
void printArray (T arr[] ,int len)
{
	for(int i=0;i<len;i++)
	{
		cout<<arr[i]<<" "<<endl;
	}
}

2.4 普通函数与函数模板的区别

1）普通函数调用时可以发生自动类型转换（隐式类型转换）
2）函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3）如果利用显示指定类型的方式，可以发生隐式类型转换

//普通函数
int myAdd01(int a,int b)
{
	return a+b;
}

//函数模板
template<class T>
T myAdd02(T a ,T b)
{
	return a+b;
}

//使用函数模板时，如果用自动类型推导，不会发生自动类型转换，即隐式类型转换
void test01()
{
	int a=10;
	int b=20;
	char c ='c';
	cout<<myadd01(a,c)<<endl; //正确，将char类型的'c'隐式转换为int类型，'c'对应ASCII码99
	//myadd02(a,c); 报错，使用自动类型推导时，不会发生隐式类型准换
	myadd02<int>(a,c); //正确，如果用显示指定类型，可以发生隐式类型转换
}

int main() {...}

总结：建议使用显式指定类型的方式，调用函数模板，因为可以自己确定通用类型T

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

1） 如果函数模板和普通函数都可以实现，优先调用普通函数
2）可以通过空模板参数列表来强制调用函数模板
3） 函数模板也可以发生重载
4) 如果函数模板可以产生更好的匹配，优先调用函数模板

myprint<>(a,b);  //通过空模板参数列表来强制调用函数模板

template <typename T>
void myprint (T a, T b)
{
	... ... 
}

template <typename T>
void myprint (T a, T b, T c) //函数模板也可以发生重载
{
	... ...
}

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。

2.6 模板的局限性

模板的通用性并不是万能的
例如：

template <class T>
void f(T a, T b)
{
	a=b;
}

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了，或传入的是像Person这样的自定义数据类型，也无法正常运行。

模板的重载，可以为这些特定的类型提供具体化的模板。

具体化，显示具体化的原型，以template<>开头，并通过名称来指出类型；
具体化优先于常规模板。

template<>bool myCompare(Person &p1 ,Person &p2)
if(p1.m_Name==p2.m_Name && p1.m_Age==p2.m_Age)
{
	return true;
}
else
{
	return false;
}

总结：利用具体化的模板，可以解决自定义类型的通用化。学习模板并不是为了写模板，而是在STL能够运用系统提供的模板。