c++函数模板

函数模板

为了交换两个int变量的值，需要编写如下Swap函数：

void Swap(int & x, int & y) {
    int tmp = x;
    x = y;
    y = tmp;
}

为了交换两个double变量的值，还需要编写如下Swap函数：

void Swap(double & x, double & y) {
    int tmp = x;
    x = y;
    y = tmp;
}

能否只写一个Swap, 就能交换各种类型的变量？用函数模板解决。

template< class 类型参数1, class 类型参数2, … >
返回值类型 模板名 (形参表) {
    函数体
}

交换两个变量值的函数模板：

template <class T>
void Swap(T & x, T & y) {
    T tmp = x;
    x = y;
    y = tmp;
}

int main(){
    int n = 1, m = 2;
    Swap(n, m);  //编译器自动生成 void Swap(int &, int &)函数
    double f = 1.2, g = 2.3;
    Swap(f, g);  //编译器自动生成 void Swap(double &, double &)函数
    return 0;
}

函数模板中可以有不止一个类型参数。

template< class T1, class T2>
T2 print(T1 arg1, T2 arg2) {
    cout << arg1 << " " << arg2 << endl;
    return arg2;
}

求数组最大元素的MaxElement函数模板：

template <class T>
T MaxElement(T a[], int size) //size是数组元素个数
{
    T tmpMax = a[0];
    for( int i = 1; i < size; ++i )
        if( tmpMax < a[i] )
            tmpMax = a[i];
    return tmpMax;
}

函数模板可以重载，只要他们的形参表不同即可。
例，下面的两个模板可以同时存在：

template<  class T1, class T2>
void print(T1 arg1, T2 arg2) {
    cout << arg1 << " "<<  arg2<<endl;
}

template<  class T>
void print(T arg1, T arg2) {
    cout << arg1 << " " << arg2 << endl;
}


C++编译器遵循以下优先顺序：

Step 1：先找参数完全匹配的普通函数（非由模板实例化而得的函数）
Step 2：再找参数完全匹配的模板函数
Step 3：再找实参经过自动类型转换后能够匹配的普通函数
Step 4：上面的都找不到，则报错
例：函数模板调用顺序

template < class T> 
T Max(T a, T b) {
    cout << "Template Max 1" << endl;
    return 0; 
} 
template < class T, class T2> 
T Max(T a, T2 b) {
    cout << "Template Max 2" <  <endl;
    return 0; 
}
double Max(double a, double b) {
    cout << "MyMax" << endl;
    return 0;
}

int main() {    
    int i=4, j=5;
    Max(1.2, 3.4);  // 调用Max(double, double)函数
    Max(i, j);      // 调用第一个T Max(T a, T b)模板生成的函数
    Max(1.2, 3);    // 调用第二个T Max(T a, T2 b)模板生成的函数
    return 0;
}

运行结果：

MyMax
Template Max 1
Template Max 2

赋值兼容规则引起函数模板中类型参数的二义性。

template< class T>
T myFunction(T arg1, T arg2) {
    cout<< arg1 <<“ ”<<arg2<<“\n”;
    return arg1;
}
…

myFunction(5, 7);  //ok: replace T with int
myFunction(5.8, 8.4);  //ok: replace T with double

myFunction(5, 8.4);  //error: replace T with int or double? 二义性

可以在函数模板中使用多个类型参数, 可以避免二义性。

template<class T1, class T2>
T1 myFunction( T1 arg1, T2 arg2) {
    cout<<arg1<<“ ”<<arg2<<“\n”;
    return arg1;
}

…

myFunction(5, 7);     //ok：replace T1 and T2 with int
myFunction(5.8, 8.4); //ok： replace T1 and T2 with double
myFunction(5, 8.4);   //ok： replace T1 with int, T2 with double

总结
函数模板的格式

　　　　template < class 形参名，class 形参名，……> 返回类型函数名(参数列表)

　　　{

　　　　　　函数体

　　　}

　　其中template和class是关见字，class可以用typename 关见字代替，在这里typename 和class没区别，<>括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名.模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。比如swap的模板函数形式为

　　　　　　template < class T> void swap(T& a, T& b){}，

当调用这样的模板函数时类型T就会被被调用时的类型所代替，比如swap(a,b)其中a和b是int 型，这时模板函数swap中的形参T就会被int 所代替，模板函数就变为swap(int &a, int &b)。而当swap(c,d)其中c和d是double类型时，模板函数会被替换为swap(double &a, double &b)，这样就实现了函数的实现与类型无关的代码。

　　2、注意：对于函数模板而言不存在 h(int,int) 这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行 h(2,3) 这样的调用，或者int a, b; h(a,b)。

函数模板

猜你喜欢