函数模板

1、模板

使用泛型来定义函数，其中的泛型可以用具体的数据类型（比如int或double）替换。通过将数据类型作为参数传递给模板，可使编译器生产该类型的函数。

1.1、为何需要函数模板

如果要交换两个int类型，则可以定义一个函数，如果要交换double类型，则可以定义另外一个函数，如果要交换float类型，则可以定义第三个函数，但是这样显得很复杂。

函数模板可以将数据类型作为参数

template <typename AnyType>
void swap(AnyType &a,AnyType &b){
    AnyType temp;
    temp = a;
    a = b;
    b = temp;
}

1.2、实例

#include <iostream>
template <typename T>
void swap(T &a,T &b);
int main(int argc , char** argv){
    using namespace std;
    int i = 10 , j = 20;
    cout << "i = " << i << ",j = " << j << endl;
    cout << "Using compiler generated int swapper\n";
    swap(i,j);//实际生成一个void swap(int &x,int &y);
    cout << "Now i = " << i << ",j = " << j << endl;

    double x =24.5 ,y = 30.2;
    cout << "x = " << x << ",y = " << y << endl;
    swap(x,y);//实际生成一个void swap(double &x,double &y);
    cout << "Now x = " << x << ",y = " << y << endl;
    return 0;
}

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

1.3、模板使用原理

1. 第一行template指出建立一个模板。关键字template和typename不可缺少。
2. 模板不创建实际函数，只是告诉编译器如何定义函数，需要交换int的函数时，编译器将按照模板创建这样的函数，并用int代替AnyType。
3. 函数模板并不减少可执行程序，可执行程序中不包含任何模板，模板只是给编译器看的，告诉编译器如何生产函数。
4. 在可执行程序中，使用手动定义函数和使用模板都是一样的，但是对于程序员而言，减少了代码量，方便写代码。这也是最大的优点。

2、重载的模板

2.1、区分重载和函数模板的意义

函数模板：对不同的数据类型，要使用相同的算法，比如对于double和int的交换，都使用swap算法。
函数重载：要使用不同的算法，调用相同的函数名。
重载的模板：当多个数据类型使用同种算法时，可使用模板，但是并非所有数据类型都使用相同算法，这时必须重载，也就是重载模板。是模板和重载结合。调用相同的函数名，使用不同算法，处理不同数据类型。

2.2、模板，重载，重载模板三者实例

举例：
比如要交换int类型，或者double类型，就可以使用模板，定义函数swap，但是如果要交换一个int数组，那么交换int的算法则不能应用在交换数组上了，因此可以进行重载swap；但是数组可能是int，也可能是double，因此这时可以使用重载模板。

#include <iostream>
template <typename T>       //声明一个模板
void swap(T &a , T &b);

template <typename T>       //声明一个重载模板，特征标不同
void swap(T *a , T *b , int n);
void show(int a[]);
const int lim = 8;

int main(int argc , char** argv){
    using namespace std;
    int i = 10 , j = 20;
    cout << "i = " << i << ",j = " << j << endl;
    cout << "Using compiler generated int swapper\n";
    //实际生成一个void swap(int &x,int &y);
    swap(i,j);
    cout << "Now i = " << i << ",j = " << j << endl;

    double x =24.5 ,y = 30.2;
    cout << "x = " << x << ",y = " << y << endl;
    //实际生成一个void swap(double &x,double &y);
    swap(x,y);
    cout << "Now x = " << x << ",y = " << y << endl;

    int d1[lim] = {0,4,6,3,2,6,8,1};
    int d2[lim] = {6,3,8,5,2,6,8,1};
    show(d1);
    show(d2);
    //匹配重载模板
    swap(d1 , d2 , lim);
    show(d1);
    show(d2);
    return 0;
}

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

template <typename T>
void swap(T a[] , T b[] , int n){
    T temp;
    for(int i = 0; i < n ; i++){
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

void show(int a[]){
    using namespace std;
    for(int i=0 ; i < sizeof(a) ; i++){
        cout << a[i] << " ";
    }
    cout << endl;
}

3、模板局限性

虽然使用模板就是为了针对不同的数据类型，但是某些特殊的类型，则可能无法处理。比如定义一个模板swap，可以处理int，double，float，但是不能处理数组，struct，等。

4、显示具体化

4.1、显示具体化的意义

要交换int或double类型，可以建立一个swap交换模板，但是如果类型是struct，则这种算法不适用。上面讲过使用重载模板，可以调用相同的函数名，使用不同的算法，但是重载模板必须是函数特征标不同，也就是函数参数个数不同。这对于swap的两个struct并不合适。

其实swap交换int和double，以及struct，参数个数都是2个，参数类型都是模板的typename T，因此不适合重载。而交换struct只不过是swap交换模板的一个特例。实现这个特例就用函数模板显示具体化。

4.2、第三代具体化

（1）对于一个同名的函数，可能最多有以下的几类函数：常规实现函数，模板显示具体化，模板函数，重载模板。
（2）显示具体化的原型和定义应以template <>开头，并通过名称指定类型。
（3）当实现了上述4类同名函数时，具体调用哪个函数，按照下面优先原则：常规函数 > 模板显示具体化 > 模板函数 。重载的模板因为参数个数不同，不同其他三个比较。

struct job{
    char name[40];
    double salary;
    int floor;
};

//常规实现函数
void swap(job &a , job &b);

//函数模板
template <typename T>
void swap(T &a , T &b>

//模板显示具体化
template <> void swap<job>(job &a , job &b);

//模板重载
template <typename T>
void swap(T &a , T &b , int n);

4.3、显示具体化实例

#include <iostream>
template <typename T>
void swap(T &a , T &b);
struct job{
    char name[40];
    double salary;
    int floor;
};
template <> void swap<job>(job &a , job &b);
void show(job &x);

int main(int argc , char** argv){
    using namespace std;
    cout.precision(2);
    cout.setf(ios::fixed,ios::floatfield);
    int i = 10 , j = 20;
    cout << "i,j=" << i << "," << j << endl;
    cout << "Using comiler-generated int swapper" << endl;
    swap(i , j );
    cout << "Now i,j=" << i << "," << j << endl;

    job sue = {"Su" , 7300.2 , 7};
    job Mik = {"Mik" , 4566.3 , 6};
    cout << "Before job swapping " << endl;
    show(sue);
    show(Mik);
    swap(sue , Mik);
    cout << "After job swapping \n" ;
    show(sue);
    show(Mik);
    ruturn 0;
}
template <typename T>
void swap(T &a , T &b){
    T temp;
    temp = a;
    a = b;
    b = temp;
}

template <> void swap<job>(job &x , job &y){
    double t1;
    int t2;
    t1 = x.salary;
    x.salary = y.salary;
    t.salary = t1;
    t2 = x.floor ;
    x.floor = y.floor;
    y.floor = t2; 
}

void show(job &x){
    using namespace std;
    cout < x.name << ":" <<x.salary << "on floor" << x.floor << endl;
}