C++模版函数

C++中的模版整体能够分为两大类：模版函数、模版类。本篇文章先写模版函数，接下来会介绍模版类。

定义：模版函数是通用的函数描述，也就是说它们使用通用类型来定义，其中的通用类型可用具体类型替换。

代码实例：

#include <iostream>//模版函数的声明template<typename T>void Swap(T& a,T& b);int main()
{    int i = 10;    int j = 20;
    std::cout<<"i=" << i << "," << "j=" <<j;
    Swap(i,j);//生成 void Swap(int &,int&);
    std::cout<<"i=" << i << "," << "j=" <<j;    double x = 11.5;    double y = 19.5;
    std::cout<<"x=" << x << "," << "y=" <<y;
    Swap(x,y);//编译器生成 void Swap(double &,double&);
    std::cout<<"x=" << x << "," << "y=" <<y;    return 0;
}//模版函数的定义template<typename T>void Swap(T& a,T& b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}

以上实例为最简单的函数模版实例，编译器会根据具体使用的类型生成相对应的函数。

重载的模版：

须要多个对不一样的类型使用同一算法时可以使用模版，如上代码所示。可是并不是全部的类型都使用相同的算法。为知足这种需求，能够像重载常规函数定义那样重载模版定义。和重载常规函数同样，重载函数的特征表必须不一样。代码实例以下：

#include <iostream>//模版函数的声明template<typename T>void Swap(T& a,T& b);const int iCount = 5;
template<typename T>void Swap(T* a,T*b,int n);int main()
{    int i = 10;    int j = 20;
    std::cout<<"i=" << i << "," << "j=" <<j;
    Swap(i,j);//生成 void Swap(int &,int&)
    std::cout<<"i=" << i << "," << "j=" <<j;    double x = 11.5;    double y = 19.5;
    std::cout<<"x=" << x << "," << "y=" <<y;
    Swap(x,y);//编译器生成 void Swap(double &,double&);
    std::cout<<"x=" << x << "," << "y=" <<y;    int d[iCount] = {0,1,2,3,4};    int e[iCount] = {5,6,7,8,9};
    Swap(d,e,iCount);//匹配新的模版，进行数组的交换

    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)
{    for (int i=0;i<iCount;++i)
    {
        T temp;
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

如上代码新增了一个模版，用于交换两个数组中的元素，原来的模版特征标为（T&，T&），新模版的特征标为（T[],T[]),int)。注意，在后一个模版中，最后一个参数的类型为具体类型（int），而不是通用类型，并不是全部的模版参数都必须是模版参数类型。

显示具体化：

• 对于给定的函数名，能够有非模版函数，模版函数和显示具体化模版函数以及它们的重载版本。

• 显示具体化的原型和定义应该以template<>打头，并经过名称来指出类型。

• 具体化将覆盖常规模版，而非模版函数将覆盖具体化和常规模版。

下面是用于交换Job结构的非模版函数，模版函数和具体化的原型。

void Swap（job &,job&);//非模版函数

template <typename T>

void Swap(T&，T&）;//模版函数

template <> void Swap<job>(job&，job&);//显示具体化函数,其中Swap后的job参数可去掉，则函数签名为template <> void Swap(job&，job&);

前面指出，若是有多个原型，编译器在选择原型时，非模版将优先于显示具体化和模版版本，而显示具体化将优先于使用模版生成的版本。

以下面的调用：

double u,v;

Swap(u,v);//使用通用的模版

job a,b;

swap (a,b)//使用显示具体化版本。

实例化和具体化：

    为了进一步了解模版，必须理解术语实例化和具体化。记住，在代码中包含函数模版自己并不会生成函数的定义，它只是一个用于生成函数定义的方案。编译器使用模版为特定类型生成定义时，获得的是模版实例（instantiation）。例如：函数调用Swap（i，j),使编译器生成一个Swap（)的一个实例，该实例使用int类型。模版并不是函数定义，但使用int的模版实例是函数定义。这种实例化方式被称为隐式实例化，由于编译器之因此知道须要定义，是因为程序调用Swap（）时提供了int参数。

    如今编译器还能够容许显示实例化，这意味着能够直接命令编译器生成特定的实例，如Swap<int>。其句法是，声明所选的种类-用<>符号指示类型，并在声明前加上关键字template:

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

实现了这种特性的编译器在看到上述声明后，将使用Swap（）模版生成一个int类型的实例。

与显示实例化不一样的是，显示具体化使用下面两个等价声明的之一：

template <> void Swap<int>(int,int);

template <> void Swap(int,int);

区别在于，这些声明的意思是”不要使用Swap()模版来生成函数定义，而应该使用独立的、专门的函数定义显示为int类型生成函数定义。

注意：试图在一个编程单元中使用同一种类型的显示具体化与显示实例化将出错。