17、函数模板

此文编写参考狄泰软件学院唐佐林老师的视频课程，如有错误之处，欢迎指正。

一、函数模板的概念和意义

1、为什么需要函数模板？

函数模板是泛型编程中的一种技术，在探讨函数模板之前，我们先了解我们为什么要学习函数模板？
c++中有几种交换变量的方法，我们至少清楚存在两种，一种是通过宏定义来实现，一种是通过函数的方式来实现，下面我们就通过实例来了解这两种方式。
例程：

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

#define SWAP(t,a,b)		\
do						\
{						\
		t c=a;			\	
		a=b;			\
		b=c;			\
}while(0);								

void swap(int& a,int& b)
{
	int c=a;
	a=b;
	b=c;
}
void swap(string& s1,string& s2)//采用函数重载的方式，函数体的写法是一样的，只是数据类型的区别
{
	string s3=s1;
	s1=s2;
	s2=s3;
}
int main()	
{
	int a=1;
	int b=2;
	SWAP(int,a,b);
	cout<<"a="<<a<<endl
			<<"b="<<b<<endl;
	
	string s1="guang";
	string s2="jie";
	SWAP(string,s1,s2);
	cout<<"s1="<<s1<<endl
			<<"s2="<<s2<<endl;

	cout<<endl;

	int c=3;
	int d=4;
	swap(c,d);
	cout<<"c="<<c<<endl
			<<"d="<<d<<endl;
	
	string s3="liang";
	string s4="yuan";
	swap(s3,s4);
	cout<<"s3="<<s3<<endl
			<<"s4="<<s4<<endl;
	return 0;
}

分析：这两种方式都实现了功能，但是实现功能是远远不够的，下面就具体分析两种实现方式的优缺点：

1、定义宏代码块

• 优点：代码复用，适合所有的类型
• 缺点：编译器不知道宏的存在，缺少类型检查

2、定义函数

• 优点：真正的函数调用，编译器对类型进行检查
• 缺点：根据类型重复定义函数，无法代码复用

那么问题来了，c++是否能够将两者的有点集合在一起呢？答案是有的。

2、函数模板的初认识

Template <typename T>
//Template告诉编译器开始泛型编程
//typename T 告诉编译器T是一个泛指类型
void Swap(T& a,T& b)
{
	T c=a;
	a=b;
	b=c;
}
int a=0;
int b=1;
Swap(a,b);//自动类型推导调用
double c=1.1;
double d=2.2;
Swap<double>(a,b);//具体类型显示调用

泛型编程	不考虑具体数据类型的编程方式,T泛指任意数据类型
函数模板	泛型编程中的一种；一种特殊的函数可以不同类型进行调用；看起来和普通函数很相似，区别是类型可被参数化
函数模板的语法规则	template关键字用于声明开始进行泛型编程，typename关键字用于声明泛指类型
函数模板的使用	自动类型推导调用,如Swap(a,b)；具体类型显示调用,如：Swap<int>(a,b)

例程：

#include<iostream>
#include<string>
using namespace std;
template <typename T>
void Swap(T& a,T& b)
{
	T c=a;
	a=b;
	b=c;
}

template <typename T>
void Sort(T a[],int len)
{
	for(int i=0;i<len;i++)
	{
		for(int j=i;j<len;j++)
		{
			if(a[i]>a[j])
			{
				Swap(a[i],a[j]);
			}
		}	
	}
}
template <typename T>
void print(T a[],int len)
{
	for(int i=0;i<len;i++)
	{
		cout<<"a["<<i<<"]="<<a[i]<<endl;
	}
	cout<<endl;
}
int main()
{
	int a[5]={1,2,5,3,4};
	Sort(a,5);
	print(a,5);
	string b[5]={"java","c","basic","python","c++"};
	Sort(b,5);
	print(b,5);
	return 0;
}

二、深入理解函数模板

1、函数模板的本质

• 编译器从函数模板通过具体类型产生不同的函数

• 编译器会对函数模板进行两次编译
  对模板本身代码进行编译
  对参数替换后的代码进行编译

• 注意：函数模板本身不允许隐式类型转换
  自动推导类型时，必须严格匹配
  显式类型指定时，能够进行隐式类型转换
  例程：

#include<iostream>
#include<string>
using namespace std;
class Test
{
Test(const Test& obj);
public:
	Test()
	{

	}
};
template <typename T>
void Swap(T& a,T& b)
{
	T c=a;
	a=b;
	b=c;
}
typedef void (FuncI)(int&,int&);
typedef void (FuncD)(double&,double&);
typedef void (FuncT)(Test&,Test&);
int main()
{
	FuncI* pi=Swap; // 编译器自动推导 T 为 int
	FuncD* pd=Swap;// 编译器自动推导 T 为 double
	//FuncT* pt=Swap;编译器自动推导 T 为 Test，
	//test.cpp:6:1: error: ‘Test::Test(const Test&)’ is private
	// Test(const Test& obj);
	//test.cpp:16:6: error: within this context
	//T c=a;

	cout<<"pi="<<reinterpret_cast<void*>(pi)<<endl;
	cout<<"pd="<<reinterpret_cast<void*>(pd)<<endl;
	return 0;
}

分析：虽然Swap同时赋值给了pi和pd,pi和pd的值是不一样的，证明了他们指向了不同的函数，或者说编译器从函数模板通过具体类型产生了不同的函数。

2、多参数函数模板

函数模板可以定义任意多个不同的类型参数

template <typename T1,typename T2,typename T3>
T1 Add(T2 a,T3 b)
{
	return static_cast<T1>(a+b);
}

• 对于多参数函数模板
  无法自动推导返回值类型
  可以从左向右部分指定类型参数
  工程中将返回值参数作为第一个类型参数！因此对于返回值参数要显式地指定。

例程如下：

#include<iostream>
#include<string>

using namespace std;

template <typename T1,typename T2,typename T3>
T1 Add(T2 a,T3 b)
{
	return static_cast<T1>(a+b);
}

int main()
{
	int r1=Add<int>(0.5,0.8);// T1 = int, T2 = double, T3 = double
	double r2=Add<double,float>(0.5,0.8);// T1 = double, T2 = float, T3 = double
	float r3=Add<float,float,float>(0.5,0.8);// T1 = float, T2 = float, T3 = float
	cout<<"r1="<<r1<<endl;
	cout<<"r2="<<r2<<endl;
	cout<<"r3="<<r3<<endl;

	return 0;
}

3、当函数模板遇上函数重载

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

int r1=Max(1,2);
double r2=Max<>(0.5,0.8);//空模板限定

例程：

#include<iostream>
#include<string>

using namespace std;

template <typename T>
T Max(T a,T b)
{
	cout<<"T Max(T a,T b)"<<endl;
	return a>b?a:b;
}
int Max(int a,int b)
{
	cout<<"int Max(int a,int b)"<<endl;
	return a>b?a:b;
}
template <typename T>
T Max(T a,T b,T c)
{
	cout<<"T Max(T a,T b,T c)"<<endl;
	return Max(Max(a,b),c);
}
int main()
{
	int a=1;
	int b=2;
	cout<<"Max(a,b)="<<Max(a,b)<<endl;
	cout<<endl;
	
	cout<<"Max<>(a,b)="<<Max<>(a,b)<<endl;
	cout<<endl;
	
	cout<<"Max(1.1,1.2)="<<Max(1.1,1.2)<<endl;
	cout<<endl;
	
	cout<<"Max(1.1,1.2,1.3)="<<Max(1.1,1.2,1.3)<<endl;
	cout<<endl;
	
	cout<<"Max('a',100)="<<Max('a',100)<<endl;
	cout<<endl;
	
	return 0;
}

三、总结

• 函数模板通过具体类型产生不同的函数
• 函数模板可以定义任意多个不同的类型参数
• 函数模板中的返回值必须显式地指定
• 函数模板可以像普通函数一样被重载