C++模板（一） ----函数模板

一、函数模板
1、先看一个简单的模板函数定义

/*
 *在标准c++98添加typename关键字之前，使用class 来创建模板，之后用typename 替代了class
 * c++98 之前的模板定义定义为: template < class AnyType> void fun(){...}
 */
template <typename AnyType>
void Swap(AnyType &a, AnyType &b) {
    AnyType temp;
    temp = a;
    a = b;
    b = temp;
    return;
}

这里继续给出调用代码:

int main()
{
    int a = 10, b = 20;
    double c = 10.1, d = 10.2;
    Swap(a, b);
    Swap(c, d);
    std::cout << "a = " << a << " b=" << b<< std::endl;
    std::cout << "c = " << c << " d=" << d << std::endl;
    system("pause");
    return 0;
}
执行结果:
a = 20 b=10
c = 10.2 d=10.1
请按任意键继续. . .

2、模板函数的重载
需要多个不同的类型使用同一种算法时，可使用模板。然而，并非所有的类型都使用相同的算法，为了满足需求，可以像重载常规函数定义那样重载模板定义。
重载模板函数代码如下:

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

template <typename AnyType >
void Swap(AnyType *a, AnyType *b,int n) {
    AnyType  temp;
    for (int i = 0; i < n; i++) {
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
    return;
}

第二个函数作用是交换数组。继续给出函数的调用，以及显示函数show();

/*用来显示数组内容*/
template <typename AnyType>
void Show(AnyType *a, int n) {
    for (int i = 0; i < n; i++) {
        std::cout << " " << a[i];
    }
    std::cout << std::endl;
}
int main()
{
    int a = 10, b = 20;
    double c = 10.1, d = 10.2;

    int aa[5] = { 0,1,2,3,4 };
    int bb[5] = { 4,3,2,1,0 };
    Swap(a, b);
    Swap(c, d);
    Swap(aa, bb,5);

    std::cout << "a = " << a << " b=" << b<< std::endl;
    std::cout << "c = " << c << " d=" << d << std::endl;
    std:: cout << "aa = ";
    Show(aa, 5);
    std::cout << "bb =";
    Show(bb, 5);
    system("pause");
    return 0;
}
执行结果:
a = 20 b=10
c = 10.2 d=10.1
aa =  4 3 2 1 0
bb = 0 1 2 3 4
请按任意键继续. . .

3、模板的局限性
通过上述代码我们可以看到，模板函数可能会遇到无法处理的某些类型。比如我们不同通过第一个模板函数用来交换数组。再比如，我们不能为一些结构或者类来使用=号进行交换(如果没有重写赋值运算符符的话)。这里c++提供2中解决方案：
第一种：重载运算符，第二种：显示具体化。
4、显示具体化
c++98标准选择了下面的方法:

• 对于给定的函数名，可以有非模板函数、模板函数和显示模板函数以及他们的重载版本。
• 显示具体化的原型和定义应以template<>打头，并通过名称来指出类型。
• 具体化优先于常规模板，而非模板优先于具体化和常规模板。
  假设有结构体
  struct job
{
char name[40];
double salary;
int floor;
};

给出非模板函数、模板函数、具体化模板函数的声明:

/*非模板函数*/
void Swap(job &, job &);
/*常规模板函数*/
template <typename T>
void Swap(T &, T &);
/*具体化模板函数*/
template<> void Swap<job>(job &, job &);

这里具体化模板函数中的< job >是可选的，因为参数列表中已有类型的声明。即可以也可以写作:template<> void Swap(job &, job &);
附上测试代码:

#include "stdafx.h"
#include <iostream>
struct job
{
    char name[40];
    double salary;
    int floor;
};

/*常规模板函数*/
template <typename T>
void Swap(T &, T &);
/*具体化模板函数*/
template<> void Swap<job>(job &, job &);

void Show(job & j);
int main() {
    using namespace std;
    cout.precision(2);
    cout.setf(ios::fixed, ios::floatfield);
    int i = 10, j = 20;
    cout << " i,j =  " << i << " , " << j << " . \n";
    cout << " 使用 template <typename T> void Swap(T & ,T &) 函数" << endl;
    Swap(i, j);
    cout << " Now i,j = " << i << " ," << j << ". \n";

    job sue = { "Susan Yaffee",7300.60,7 };
    job sindney = { "Sidney Tafee",78060.72,9 };
    cout << "Before job swapping : \n";
    Show(sue);
    Show(sindney);
    Swap(sue, sindney);
    cout << " after job swapping: \n";
    Show(sue);
    Show(sindney);
    system("pause");
    return  0;

}
/*常规模板函数*/
template <typename T>
void Swap(T & a, T & b) {
    T temp;
    temp = a;
    a = b;
    b = temp;
}
/*
*具体化模板函数
*这个函数值交换job中的 salary 和 floor
*/
template<> void Swap<job>(job & a, job & b) {
    double t1;
    int t2;

    t1 = a.salary;
    a.salary = b.salary;
    b.salary = t1;

    t2 = a.floor;
    a.floor = b.floor;
    b.floor = t2;
}

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

执行结果:
 i,j =  10 , 20 .
 使用 template <typename T> void Swap(T & ,T &) 函数
 Now i,j = 20 ,10.
Before job swapping :
Susan Yaffee : $7300.60 on floor 7
Sidney Tafee : $78060.72 on floor 9
 after job swapping:
Susan Yaffee : $78060.72 on floor 9
Sidney Tafee : $7300.60 on floor 7
请按任意键继续. . .

5、实例化
在代码中包含函数模板本身并不会生成函数定义，它只是一个用于生成函数定义的方案。模板并非函数定义。
c++中有2种模板函数实例化。第一种是隐式实例化（最常用的一种），第二种为显示实例化。
隐式实例化就是，我们上文中用到调用时用到的那样:

int i = 10, j = 20;
    Swap(i, j);

这就是隐式实例化，他最终生成了一个 函数定义他的参数类型为int型。即：void Swap(int i,int j){}
显示实例化则需要用 <> 指示出类型 并在声明前加上关键字 template。

//显示实例化
template void Swap<int>(int &, int &);

注意显示具体化声明在关键字template后含有< > 而显示实例化没有

综上：我们见识了隐式实例化，显示实例化和显示具体化。他们都被成为具体化。
他们的相同之处在于，他们表示的都是使用具体类型的函数定义，而不是通用描述。