• 作者: 雪山肥鱼
• 时间：20211218 16:45
• 目的: 函数模板

# 函数模板的实例化
# 函数模板参数推断
# 各种推断比较与空模板参数列表推断
# 函数模板的重载
# 泛化与特化
   ## 全特化
   ## 偏特化
# 函数模板的默认参数
# 非类型模板参数

函数模板的实例化

template<typename T>
T Sub( T tv1, T tv2) 
{
  return tv1 - tv2;
}

int main( ) {
    int sub = Sub(3, 5);
    cout << "int sub v1 = " << sub << endl;
    double sub2 = Sub(4.7, 3.1);
    cout << "double sub v2 = " << sub2 << endl;
        Sub<double>(3,5)； 会自动看成double类型
}

函数模板可以兼容多个类型，如上所示。实际上在编译阶段是实例化出来两个函数：

//"int __cdecl _nmsp1::Sub<int>(int,int)" 实例化后的函数名
    //"double __cdecl _nmsp1::Sub<double>(double,double)

然而不合理的实例化依旧是有问题的，比如类型传入的是 string，编译期间就会报错。

string a("abc"), b("efg");
string addresult = Sub(a, b); //自动推断，不合法

编译阶段，编译器会查看函数模板的函数体部分，来确定针对类型 string，是否能进行运算。string + 可以，但不可以做减法运算。

实例化后，编译器在后续工作需要找到函数模板的函数体部分，正常项目中需要把函数模板宝库函数体写道一个.h or .hpp 中，与其他函数声明略有不同

函数模板参数推断

template<typename V, typename T, typename U>
V Add（T tv1, U tv2）{
  return tv1 + tv2;
}

int main() {
  cout << Add(15,17.8)<<endl;
}

上述代码编译错误：无法推断 计算结果U 的类型，也就是说，编译阶段只管编译的事情，无法推导出 15 + 17.8 的结果 和 类型。

cout<<Add<double>(15,17,7)<<endl；

double 指定的的是第一个 typename 的类型。模板的默认参数，是从前往后。与普通函数不同。

各种推断的比较以及空模板参数列表推断

template<typename T>
T mydouble(T tmpvalue) {
    return tmpvalue + 2;
}

double mydouble(double tmpvalue) {
    return tmpvalue + 2;
}

int main(int argc, char ** argv) {
    //1.自动推断:
    cout << mydouble(15) << endl;

    //2. 指定类型模板参数
    int result2 = mydouble<int>(16.9);//有警告，但没有错误，16.9
    cout << result2 << endl;//数据会丢.

    //3. 指定空模板参数类型
    auto result3 = mydouble<>(16.9);//空的<>没有用，但语法允许，使用场景。
        //有另一个mydouble 函数，因为优先调用普通函数，所以指定<> 让其调用函数模板
    cout << result3 << endl;
    return 0;
}

模板与普通函数同名，优先调用普通函数

模板的重载

template<typename T>
void myfunc(T tmpvalue) {
    cout << "myfunc(T tmpvalue)" << endl;
}

template<typename T>
void myfunc(T * tmpvalue) {
    cout << "myfunc(T * tmpvalue)" << endl;
}

void myfunc(int tmpvalue) {
    cout<< "myfunc(int tmpvalue)" << endl;
}

int main(int argc, char ** argv) {

    myfunc(12);//有普通函数重载，优秀选择普通函数

    char *p = nullptr;
    myfunc(p); //调 T *

    myfunc(12.1);

    return 0;
}

当模板遇到普通函数时，还是优先调用普通函数。

泛化与特化

泛化，就是常规的函数模板
特化，往往从泛化抽出来一组子集
先得有泛化，才能有特化

全特化

template<typename T, typename U>
void tfunc(T & tmprv, U & tmprv2) {
    cout << "tfunc 泛化版本" << endl;
    cout << tmprv << endl;
    cout << tmprv2 << endl;
}

// int ,double 可以省略
template<>
void tfunc<int, double>(int & tmprv, double & tmprv2) {
    cout << "---------------begin------------------" << endl;
    cout << "特化版本" << endl;
    cout << tmprv << endl;
    cout << tmprv2 << endl;
    cout << "-------------------end------------------" << endl;
}

int main(int argc, char **argv) {
    const char* p = "I love china";
    int i = 12;

    //T:const char *, U:int 
    //tmprv: const char * &, tmprv2 :int &
    tfunc(p, i);


    int k = 12;
    double db = 12.4;
    tfunc(k, db);

    return 0;
}

全特化 约等于 实例化了一个函数模板，并不等于 函数重载，效果差不多，但如果同时存在，依旧会优先选择普通函数。
编译器参考优先级:

1. 普通函数
2. 特化版本
3. 函数模板

偏特化

函数模板的偏特化与类模板的偏特化是很不相同的。

• 数量上的偏特化

// 当然必须先有泛化，才能有特化
template<typename T, typename U>
void tfunc(T & tmp1, U& tmp2) {
    cout << "tfunc 泛化版本" << endl;
    cout << tmp1 << endl;
    cout << tmp2 << endl;
}

/*编译错误*/
template<typename U>
void tfunc<double, U>(double & tmp1, U & tmp2) {
}

/*编译错误*/
template<typename T, typname U>
void tfunc<double, U>(double & tmp1, U &tmp2) {

}

//只有通过重载（无模板参数）
template<typename U>
void tfunc(double & tmp1, U & tmp) {

}

• 范围上的偏特化
  范围上指的是: int -> const int 类型变小。
  T -> T*, T-> T&, T-> T&&(右值引用)
  以上范围 其实都是一直在缩小。
  实际上，对于函数模板来讲，也不存在模板参数范围上的偏特化，依然用重载的方式解决。

template<typename T, typename U>
void tfunc(T & tmp1, U& tmp2) {
    cout << "tfunc 泛化版本" << endl;
    cout << tmp1 << endl;
    cout << tmp2 << endl;
}

template<typename T, typename U>
void tfunc(const T & tmp1, U &tmp2) {

}

上者是两个函数，是重载。

尽量别考虑函数的偏特化，采用重载

函数模板的默认参数

默认 可不是 偏特化！

int mf(int tmp1, int tmp2) {
    return 1;
}

int mf2(int tmp1, int tmp2) {
    return 2;
}

typedef int(*FunType) (int ,int);

template<typename T, typename F = FunType>
void testFun(T i, T j, F function = mf) {
  cout<<mf(i, j)<<endl;
}

int main() {
    testFunc(10, 12);
    testFunc(13, 14, mf2);

    testFunc2(15, 16);
    return 0;
}

当然函数模板的默认参数是可以写在前面的，不像类模板只能写在后面

template<typename F = FunType, typename T>
void testFunc2(T i, T j, F function = mf) {
    cout << mf(i, j) << endl;
}

非类型模板参数

类型模板参数，即typename T， T本身代表了某种类型。
非类型模板参数，即普通类型：

//template<typename T, typname U, auto val = 100>
template<typename T, typename U, int val = 100>
 auto add(T t1, U u1) {
     return t1 + u1 + val;
}


int main() {
    cout << add<float, float>(22.1f, 11.0f) << endl;
    cout << add<float, float, 800>(22.1f, 11.0f) << endl;

    //编译错误，k 是变量，编译期间并不知道
    /*
    int k = 1000;
    cout << add<float, float, k>(22.1f, 11.0f) << endl;
    */
    return 0;
}

非类型模板参数 一定要是常量，否则编译不过，因为编译期间 不知道变量的值。当然也可以用auto 进行推断。

并不是所有类型都可以当作非类型模板参数
int 可以，double，float 等不行，但是指针是可以的

1. 整形
2. 指针类型
3. 左值，引用
4. auto or decltype(auto)

• typename
  有时候会看到如下写法

template<typename T, typename U, typename int val  =100>

int 前面的typename ，相当于说明 int 是一个类型。