C++进阶剖析（二十四）之函数模板

1.1泛型编程

1.1.1 思考

• C++中有几种交换变量的方式？

1.1.2 解答

• 定义宏代码块 和 定义函数
• 定义宏代码块代码

#define  SWAP(t ,a, b)  \
do						\
{						\
	t c  = a;			\
	a = b;				\
	b = c;				\
} while(0)
int main()
{
	int a =1;
	int b =2;
	SWAP(int ,a,b);
	cout<<"a = "<<a <<endl;
	cout<<"b = "<<b <<endl;

	double m = 1.2;
	double n = 2.4;
	SWAP(double ,m, n);
	cout<<"m = "<<m <<endl;
	cout<<"n = "<<n <<endl;
	return 0;
}

• 结果
  

• 定义函数

void Swap(int &a,int &b)
{
	int c =a;
	a =b;
	b =c;
}
void Swap(double&a,double&b)
{
	double c =a;
	a =b;
	b =c;
}
void Swap(string &a, string  &b)
{
	string c =a;
	a =b;
	b =c;
}

• 上面存在的问题是每当我们交换变量的值的时候，都需要定义不同的类型，而使用宏不安全。需要找一个综合性的解决方案

• 定义宏代码块

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

• 定义函数

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

• 那么C++中是否存在解决方案集合两种方法的优点？

1.1.3概念

• 不考虑具体数据类型的编程方式
• 对于Swap 函数可以考虑下面的泛型写法

void  Swap(T &a, T&b)
{
	T t  =a;
	a = b;
	b = t;
}

• Swap 泛型写法中的T不是一个具体的数据类型，而是泛指任意的数据类型

1.1.4 语法规则
template 关键字用于声明开始进行范式编程
typename关键字用于声明泛指类型

template  <typename T>   //template   告诉编译器开始泛型编程，  <typename T> 告诉编译器T是一个泛指类型
void  swap(T&a,T&b)
{
T c =a;
a =b;
b =c;
}

1.1.5 函数模板的使用

• 自动类型推导调用
• 具体类型显示调用

int a =10;
int b =20;
Swap(a, b)    //自动推导
float c =2;
float d =3;
Swap<float>(c,d);   //显示调用

• 函数模板举例

template <typename T>
void Swap(T & a, T & b)
{
	T c =a;
	a =b;
	b =c;
}


template <typename T>
void Sort(T * array, int len)
{
	for(int i =0 ;i<len ;i++)
	{
		for(int j =i ;j<len ;j++)
		{
			if(array[i] >array[j])
			{
				Swap(array[i],array[j]);
			}
		}
	}
}
template <typename T>
void print(T a[],int len)
{
	for(int i=0;i<len;i++)
	{
		cout<<a[i]<<",";
	}
	cout<<endl;
}

int main()
{
	int a =1;
	int b = 2;
	Swap(a,b);
	cout<<"a = "<<a <<endl;
	cout<<"b = "<<b <<endl;
	double m =2.4;
	double n =4.8;
	Swap(m,n);
	cout<<"m = "<<m <<endl;
	cout<<"n = "<<n <<endl; 
	
	string s1="zhangsan";
	string s2="lisi";
	Swap<string>(s1,s2);
	cout<<"s1 = "<<s1<<endl;
	cout<<"s2 = "<<s2<<endl;


	cout<<"======================="<<endl;
	int arr[] = {10,3,5,6,1,2};
	Sort<int>(arr,sizeof(arr)/sizeof(arr[0]));
	print<int>(arr,sizeof(arr)/sizeof(arr[0]));

	string ss[5] ={"zhangsan","lisi","wangwu","aaaaa","bbbb"};
	//string s[5] = {"Java", "C++", "Pascal", "Ruby", "Basic"};
	Sort<string>(ss,sizeof(ss)/sizeof(ss[0]));
	print<string>(ss,sizeof(ss)/sizeof(ss[0]));

	return 0;
}

• 结果
  

1.2 深度理解函数模板

1.2.1 函数模板深入理解

• 编译器从函数模板通过具体类型产生不同的函数
• 编译器会对函数模板进行两次编译
  （1） 对模板代码本身进行编译
  （2）对参数替换后的代码进行编译

1.2.2 注意事项
函数模板本身不允许隐式类型转换

• 自动推导类型时候，必须严格匹配
• 显示类型指定时，能够进行隐式类型转换

1.2.3 示例代码

#include <iostream>
using namespace std;

template <typename T>

void Swap(T & a,T &b)
{
	T c =a;
	a = b;
	b = c;
}
class Test
{
public:
	Test()
	{
	}
private:
//Test(const Test&);   //这里如果将copy构造函数声明为私有的，那么就会报错，因为在swap中调用了copy构造函数
};

typedef void (FuncI)(int &,int&);
typedef void (FuncD)(double& ,double&);
typedef void (FuncT)(Test&,Test&);

int main()
{
	FuncI * pi = reinterpret_cast<FuncI *>(Swap);
	FuncD *pd  =reinterpret_cast<FuncD*>(Swap);
	FuncT * pt =reinterpret_cast<FuncT*>(Swap);
	cout<<"pi =" <<pi<<endl;
	cout <<"pd =" <<pd<<endl;
	cout<<"pt="<< pt<<endl;
	return 0;
 }

1.3

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

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

1.3.2 多参数函数模板

• 无法自动推导返回值类型
• 可以从左向右部分指定类型参数

int  r1 = add<int>(0.5,0.8);
int  r2 = add<int,float>(0.5,0.8);
int  r3 = add<int,float,float>(0.5,0.8);
工程中将返回值类型作为第一个参数。

1.4 函数重载遇上函数模板
1.4.1

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

1.4.2 案例

#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) << endl;                   // 普通函数 Max(int, int)
    cout << Max<>(a, b) << endl;                 // 函数模板 Max<int>(int, int)
    cout << Max(3.0, 4.0) << endl;               // 函数模板 Max<double>(double, double)
    cout << Max(5.0, 6.0, 7.0) << endl;          // 函数模板 Max<double>(double, double, double)
    cout << Max('a', 100) << endl;               // 普通函数 Max(int, int)
    return 0;								//函数模板本身不会进行隐式转换
}

参考一 ：狄泰软件学院C++进阶剖析
参考二 ： C++ primer中文版