C++基础（10） 函数模板

1 .模板概念

c++提供了函数模板(function template.)所谓函数模板实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板 。 凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。

• c++提供两种模板机制:函数模板和类模板
• 类属 - 类型参数化，又称参数模板

总结

• 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，成为类属。
• 模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为

2. 函数模板

2.1 概念

//交换int数据
void SwapInt(int& a,int& b){
	int temp = a;
	a = b;
	b = temp;
}

//交换char数据
void SwapChar(char& a,char& b){
	char temp = a;
	a = b;
	b = temp;
}
//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数
//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度

//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换
//我们有一种技术，可以实现类型的参数化---函数模板


//class 和 typename都是一样的，用哪个都可以
template<class T>
void MySwap(T& a,T& b){
	T temp = a;
	a = b;
	b = temp;
}

void test01(){
	
	int a = 10;
	int b = 20;
	cout << "a:" << a << " b:" << b << endl;
	//1. 这里有个需要注意点，函数模板可以自动推导参数的类型
	MySwap(a,b);
	cout << "a:" << a << " b:" << b << endl;

	char c1 = 'a';
	char c2 = 'b';
	cout << "c1:" << c1 << " c2:" << c2 << endl;
	//2. 函数模板可以自动类型推导，那么也可以显式指定类型
	MySwap<char>(c1, c2);
	cout << "c1:" << c1 << " c2:" << c2 << endl;
}

用模板是为了实现泛型，可以减轻编程的工作量，增强函数的重用性。

1.2 练习

使用函数模板实现数组排序

#include<iostream>
#include<string>
using namespace std;
template <class T>
void arrayswap(T& a,T& b)
{
	T tmp = a;
	a =b;
	b =tmp;
}
//选择排序模板
template<class T>
void Selectsort(T arr[],int len)
{
	int max =0;
	for(int i = 0;i<len;i++)
	{
		max = i;
		for(int j = i+1;j<len;j++)
		{
			if(arr[max]<arr[j])
				max = j;
		}
		if(i!=max)
			arrayswap(arr[i],arr[max]);
	}
}
template<class T>
void Myprint(T arr[],int len)
{
	cout<<"数组:"<<endl;
	for (int i = 0; i < len; i++)
	{
		cout<<arr[i]<<"  ";
	}
	cout<<endl;
}
void main()
{
	int arr[10] = {11,52,36,89,75,74,62,98,100,21};
	char arr1[10]= {'c','d','w','e','m','l','k','g','h','f'};
	Selectsort(arr1,10);//11 21 36 
	Selectsort(arr,10);
	Myprint(arr,10);
	Myprint(arr1,10);
}

1.3函数模板和普通函数区别

• 函数模板不允许自动类型转化
• 普通函数能够自动进行类型转化

#include<iostream>
#include<string>
using namespace std;
template<class T>
T myadd(T a,T b)
{
	return a+b;
}

int myadd(int a,int b)
{
	return a+b;
}

void main()
{
	int a=10;
	char c='c';
	//函数模板不允许自动类型转化
	//myadd<>(a,c);//报错
	//普通函数能够自动进行类型转化
	int f = myadd(a,c);
	cout<<f<<endl;//109 char c自动转为c在ascII码中的99
}

函数模板不允许自动类型转换，必须严格匹配类型
普通函数可以进行自动类型转换

1.4函数模板和普通函数在一起调用规则

• c++编译器优先考虑普通函数
• 可以通过空模板实参列表的语法限定编译器只能通过模板匹配
• 函数模板可以像普通函数那样可以被重载
• 如果函数模板可以产生一个更好的匹配，那么选择模板

tip:

• 编译器并不是把函数模板处理成能够处理任何类型的函数
• 函数模板通过具体类型产生不同的函数
• 编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译
• 模板不是万能的，不能通用所有的数据类型

#include<iostream>
#include<string>
using namespace std;

template<class T>
T myadd(T a,T b)
{
	return a+b;
}

int myadd(int a,int b)
{
	return a+b;
}

//函数模板重载
template<class T>
T myadd(T a, T b, T c){
	T ret = a + b + c;
	return ret;
}
void main()
{
	int a=10;
	int b = 20;
	int z =10;
	char c='c';
	double e=22.2;
	double g=22.3;
	//普通函数优先调用
	int f = myadd(a,c);
	//强制使用模板函数进行调用
	int d=myadd<>(a,b);
	//如果函数模板可以产生一个更好的匹配，那么选择模板
	double s = myadd(e,g);
	//函数模板可以重载
	int k=myadd(a,b,z);

	cout<<d<<endl;//30
	cout<<f<<endl;//109 char c自动转为c在ascII码中的99
	cout<<s<<endl;//44.5
	cout<<k<<endl;//40
}

1.5 模板实现机制

函数模板机制结论：

• 编译器并不是把函数模板处理成能够处理任何类型的函数
• 函数模板通过具体类型产生不同的函数
• 编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

模板的局限性：
代码实现时定义了赋值操作 a = b，但是T为数组，这种假设就不成立了

如果里面的语句为判断语句 if(a>b),但T如果是结构体，该假设也不成立，另外如果是传入的数组，数组名为地址，因此它比较的是地址，而这也不是我们所希望的操作。

编写的模板函数很可能无法处理某些类型，另一方面，有时候通用化是有意义的，但C++语法不允许这样做。为了解决这种问题，可以提供模板的重载，为这些特定的类型提供具体化的模板。

class Person
{
public:
	Person(string name, int age)
	{
		this->mName = name;
		this->mAge = age;
	}
	string mName;
	int mAge;
};

//普通交换函数
template <class T>
void mySwap(T &a,T &b)
{
	T temp = a;
	a = b; 
	b = temp;
}
//第三代具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<>void  mySwap<Person>(Person &p1, Person &p2)
{
	string nameTemp;
	int ageTemp;

	nameTemp = p1.mName;
	p1.mName = p2.mName;
	p2.mName = nameTemp;

	ageTemp = p1.mAge;
	p1.mAge = p2.mAge;
	p2.mAge = ageTemp;

}