函数模板

泛型编程：不考虑具体数据类型的编程模式
函数模板：和普通函数相似，区别是类型可被参数化
Template：关键字用于声明开始进行泛型编程
typename：关键字用于声明泛指类型

template <typename T>
void Swap(T&a,T&b)
{
	T t=a;
	a=b;
	b=t;
}
int main() 
{
	int a=1,b=2;
	Swap(a,b);	//自动类型推导 
	
	float c=3.0,d=4;
	Swap<float>(c,d);	//显式类型调用 
	return 0;
}

——————/泛型排序算法

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

template<typename T>
void SelectSort(T array[], int length)
{
    for(int i=0; i<length; i++)
    {
        T min = array[i];
        int index = i;
        for(int j=i+1; j<length; j++)
        {
            if( array[j] < min )
            {
                min = array[j];
                index = j;
            }
        }
        Swap(array[i], array[index]);
    }
}

int main(int argc, char *argv[])
{
    int array[] = {3, 2, 5, 3 , 4};
    SelectSort<int>(array, 5);
    for(int i=0; i<5; i++)
    {
        cout<<array[i]<<endl;
    }
    
    char ca[] = {'b', 'c', 'a', 'e', 'd', 'f'};
    SelectSort(ca, 6);
    for(int i=0; i<6; i++)
    {
        cout<<ca[i]<<endl;
    }
    return EXIT_SUCCESS;
}

——————/
函数模板深入理解：
编译器并不把函数模板处理成能处理任意类型的函数
函数模板通过具体类型产生不同函数，如上例Swap，单步编译为汇编，其包含三个SwapXXX(模板本身+两次调用)
——————/函数模板遇上函数重载
函数模板可像普通函数一样被重载
编译器优先考虑普通函数
如函数模板可产生一更好匹配，则选择模板
可通过空模板实参列表的语法限定编译器只通过模板匹配

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)
{
    cout<<"T Max(T a, T 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 argc, char *argv[])
{
    int a = 1;
    int b = 2;
    cout<<Max(a, b)<<endl;
    cout<<Max<>(a, b)<<endl;	//限定只通过模板匹配
    cout<<Max(3.0, 4.1)<<endl;	//更好的匹配
    cout<<Max(5.0, 6.0, 7.0)<<endl;
    cout<<Max('a', 100)<<endl;
    return EXIT_SUCCESS;
}

结果：
int Max(int a, int b)
2
T Max(T a, T b)
2
T Max(T a, T b)
4.1
T Max(T a, T b, T c)
T Max(T a, T b)
T Max(T a, T b)
7
int Max(int a, int b)
100
函数模板不允许自动类型转换(严格匹配类型)，如Max('a', 100)，必然调用…
普通函数可进行自动类型转换
——————/
函数模板可定义多个不同类型参数
当返回值类型为泛指类型时，无法进行自动类型推导，必显式…
将RT放到第一个参数位置，调用时只需显式声明返回类型即可

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

int main(int argc, char *argv[])
{
    cout<<Add<double, char, float>('a', 100.0f)<<endl;
    cout<<Add<double>('a', 100.0f)<<endl;
    return EXIT_SUCCESS;
}

结果：197 197
函数模板其实是一具相同行为的函数家族、函数模板可以被重载