函数模板

函数模板适用场景：

函数的业务逻辑一样
函数的参数类型不一样

函数模板特性：

函数模板可以被重载
编译器优先匹配普通函数
可以通过调用时候加<>强制调用模板函数

#include <iostream>

using namespace std;

//template告诉编译器，下面是泛型编程，看到T，不要报错
template<typename T>
void mySwap(T& a, T&b) {
    T tmp;
    tmp = a;
    a = b;
    b = tmp;
}

int main() {
    
    // 函数模板的调用
    // 1. 显示类型调用
    {
        int x = 10;
        int y = 33;
        mySwap<int>(x, y);
        cout << "x = "<< x << "  y = "<<y << endl;
    }
    // 2. 自动类型推导
    {
        char x = 'a';
        char y = 'b';
        mySwap(x, y);
        cout << "x = "<< x << "  y = "<<y << endl;
    }
    return 0;
}

函数模板当函数参数

#include <iostream>

using namespace std;

template<typename T, typename T1>
void mySort(T * array, T1 size) {
    if (array == NULL)
    {
        return;
    }
    T tmp;
    for (size_t i = 0; i < size; i++)
    {
        for (size_t j = i+1; j < size; j++)
        {
            if (array[i] < array[j])
            {
                tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            } 
        }
    }
}

template<class T, class T1>
void myPrint(T * array, int size) {
    for (size_t i = 0; i < size; i++)
    {
        cout << array[i] << "   ";
    }
}    

int main() {
    int int_array[] = {11,23,42,6,7,8,9};
    int size = sizeof(int_array) / sizeof(int_array[0]);
    mySort<int, int>(int_array, size);

    myPrint<int, int>(int_array, size);
    return 0;
}

函数模板的调用和参数推导

#include <iostream>

using namespace std;

template<typename T>
T myAdd(T a, T b) {
    return a+b;
}

int myAdd(int a, char b) {
    return a + b;
}

#if 0
int myAdd(int a, int b) {
    return a + b;
}
#endif

int main() {
    int a = 10;
    int b = 20;
    char c = 'a';
    char d = 'd';

    myAdd(a, c); // int myAdd(int a, char b)
    myAdd(a, b); // T myAdd(T a, T b)  函数模板必须严格类型匹配
    myAdd(c, b); // int myAdd(int a, char b)   普通函数可以进行自动类型转换
    // myAdd(a, b); // int myAdd(int a, char b)  编译器优先匹配普通函数
    myAdd<>(a, b); // T myAdd(T a, T b)  通过<> 强制调用模板函数

    return 0;
}

函数模板类型参数默认值

template<class T1,class T2=int> // 这里表示的是类型的默认值
void fun1(T1 a, T2 b=123) { //b参数默认值为123

}

函数模板特化

template<class T1, class T2>
void fun01(T1 a, T2 b) {
    cout <<"函数模板.."<<endl;
}

// 函数模板特化，函数名必须和函数模板相同
template<>
void fun01<int,double>(int a, double b) {
    cout <<"函数模板全特化..."<<endl;
}
// 函数模板偏特化
template<class T1=int,class T2>
void fun01(int a, T2 b) {
    cout <<"函数模板局部特化..."<<endl;
}