函数模板

函数模板是通用的函数描述，它们使用泛型来定义函数，其中的泛型可用具体的类型替换。通过将类型作为参数传递给模板，可使编译器生成该类型的函数。

1、语法：

template<typename 类型>

返回值类型 函数名（类型 a, 类型 b）{}

关键字template和typename是必不可少的，其中typename可用class替换，因为typename是在C++98才引入的，之前都是用class；类型为任意类型，包括自定义类型；

举例：

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

int main()
{
    int a1 = 1, a2 = 2;
    cout << "a1 = " << a1 << ", a2 = " << a2 << endl;
    Swap(a1, a2);
    cout << "a1 = " << a1 << ", a2 = " << a2 << endl;

    float f1 = 1.1f, f2 = 2.2f;
    cout << "f1 = " << f1 << ", f2 = " << f2 << endl;
    Swap(f1, f2);
    cout << "f1 = " << f1 << ", f2 = " << f2 << endl;

    return EXIT_SUCCESS;
}

结果：

 

2、重载模板：

可以像重载函数那样重载函数模板，和常规重载一样，被重载的模板的函数特征标必须不同。

举例：

const int arrayLen = 4U;

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 var = 0; var < n; ++var) {
        temp = a[var];
        a[var] = b[var];
        b[var] = temp;
    }
}

void Show(int a[])
{
    cout << a[0] << "," << a[1] << ",";
    cout << a[2] << "," << a[3] << ",";
    for (int i = 4; i < arrayLen; i++) {
        cout << a[i];
    }
    cout << endl;
}

int main()
{
    int i = 10;
    int j = 20;
    cout << "i = " << i << ", j = " << j << endl;
    Swap(i, j);
    cout << "i = " << i << ", j = " << j << endl;

    int arr1[arrayLen] = {0, 1, 2, 3};
    int arr2[arrayLen] = {10, 9, 8, 7};
    Show(arr1);
    Show(arr2);
    Swap(arr1, arr2, arrayLen);
    Show(arr1);
    Show(arr2);

    return EXIT_SUCCESS;
}

 

3、模板的局限性

假设有如下模板函数：

template<typename T>

void f(T a, T b)

{a=b;}

当a为数组时这种方式不成立；总之编写的模板函数很可能无法处理某些类型。

类似于上述情况，比较好的解决方式是为特定类型提供具体化的模板定义。

4、显式具体化

函数原型相同，实现算法不同时，可以使用显式具体化提供一个具体化函数定义，当编译器找到与函数调用匹配的具体化定义时，将使用该定义，而不再寻找模板；

<1>对于给定的函数名,可以有非模板函数/模板函数和显示具体化模板函数以及它们的重载版本.

<2>显示具体化的原型和定义应以template<>打头,并通过名称来指出类型.

<3>具体化优先于常规模板,而非模板函数优先于具体化和常规模板.

举例:

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

template<> void Swap<int>(int& a, int& b)
{
    a += 1;
    b += 1;
}

int main()
{
    char c1 = 'A', c2 = 'B';
    cout << "c1 = " << c1 << ", c2 = " << c2 << endl;
    Swap(c1, c2);
    cout << "c1 = " << c1 << ", c2 = " << c2 << endl;

    int i1 = 1, i2 = 2;
    cout << "i1 = " << i1 << ", i2 = " << i2 << endl;
    Swap(i1, i2);
    cout << "i1 = " << i1 << ", i2 = " << i2 << endl;


    return EXIT_SUCCESS;
}

结果:

 

可见char类型的变量使用的是函数模板生成的char类型交换函数,int类型的交换使用的是显示具体化的函数.

5、实例化和具体化

实例化：

定义好函数模板后，编译阶段编译器会根据参数类型进行特定类型的函数定义，这种方式成为隐式实例化；

C++还允许显式实例化，template Swap<int>(int&, int&);注意template后面没有<>，这是和显示具体化的区别；显示的告诉编译器去定义一个参数为int类型的Swap函数；

显示具体化是显示的定义一个和函数模板原型相同但是实现不同的函数；----函数内部实现和模板不同；

显示实例化是显示的定义一个以函数模板为原型的具体类型的函数实现；----函数内部实现和模板相同；