LoadMap9：C++的Template模板函数

1. 模板函数与模板类

模板Template和函数重载是实现静态多态的两种重要途径。对于模板而言，其通常用于模板函数和模板类中。其基本语法结构为：

template <typename XXXX>  // XXXX 代表定义的模板数据类型的名称

1.1 模板函数

使用 template 关键字定义类型，用定义好的新类型定义函数类型以及其参数类型。调用模板函数式方法：函数名<函数参数类型>（参数列表），若实参并非该指定类型，则先进行强制转换，或者不显式说明函数参数类型，由编译器自主推断，此时输出参数的类型必须一致。

#include<iostream>
using namespace std;

// 1.1 模板函数
template<typename ftype>            // 使用 template 关键字定义类型， 可以同时定义多个类型
ftype myMax(ftype a, ftype b){      // 用定义好的新类型定义函数类型以及其参数类型
    return (a > b) ? a : b;
}

int main(){
    int a = 10, b = 15;
    int ans1 = myMax<int>(a, b);        // 调用模板函数方法1：函数名<函数参数类型>（参数列表）
    int ans2 = myMax(a, b);             // 调用目标函数方法2：不显式说明函数参数类型，由编译器自主推断
    cout << "ans1: " << ans1 << endl;
    cout << "ans2: " << ans2 << endl;
}

1.2 模板类

类似于模板类，使用 template 关键字定义类型，可以同时定义多个类型，然后就可以用定义好的新类型定义成员变量的函数类型，类中构造函数/其他函数使用模板参数类型就类似于模板函数的使用方法。调用方法可以不显式说明函数参数类型，由编译器自主推断，也可以函数名<函数参数类型>（参数列表），若实参并非该指定类型，则先进行强制转换。

#include<iostream>
using namespace std;

// 1.2 模板类
template <typename ctype, typename btype>       // 使用 template 关键字定义类型，可以同时定义多个类型
class myclass{
    public:
        ctype m_var1;           // 用定义好的新类型定义成员变量的函数类型
        btype m_var2;

        myclass(ctype var1, btype var2) : m_var1(var1), m_var2(var2){   // 构造函数/其他函数：类似于模板函数的使用方法
            cout << "m_var1: " << m_var1 << endl;
            cout << "m_var2: " << m_var2 << endl;
        };
};


int main(){
    int a = 10;
    float b = 15;
    myclass cls1(a, b);             // 调用方法1：不显式说明函数参数类型，由编译器自主推断
    myclass<int, float> cls2(a, b);     // 调用模板函数方法2：函数名<函数参数类型>（参数列表），若实参并非该指定类型，则先进行强制转换
}

1.3 模板特定化

类似于函数重载，当我的同一个名字的类有多种不同的实现方法时，我希望编译器能够根据我指定的类参数类型自动匹配对应的类实现方法时，可以使用模板特定化的功能。以下展示 myclass 类的两种使用方法，当指定类型为 char 类型时，则编译器自动调用第二种类型，即把小写字母转化为大写字母，否则自动调用第一种类的实现方法，即直接打印输出。

#include<iostream>
using namespace std;

// myclass 模板类的第一种实现方法
template <typename ctype, typename btype>       // 使用 template 关键字定义类型，可以同时定义多个类型
class myclass{ 
    public:
        ctype m_var1;           // 用定义好的新类型定义成员变量的函数类型
        btype m_var2;

        myclass(ctype var1, btype var2) : m_var1(var1), m_var2(var2){   // 构造函数/其他函数：类似于模板函数的使用方法
            cout << "m_var1: " << m_var1 << endl;
            cout << "m_var2: " << m_var2 << endl;
        };
};

// myclass 模板类的第二种实现方法
template <>
class myclass<char, char> {       // 类型为 char 型时调用
public:
    char first;
    char second;

    myclass(char first, char second) : first(first), second(second) {
        // Special behavior for characters (e.g., convert to uppercase)
        cout << char(std::toupper(this->first)) << endl;   // 转化为大写
        cout << char(std::toupper(this->second)) << endl;
    };
};


int main(){
    int a = 10;
    float b = 15;
    char c = 'c', d = 'd';
    myclass<int, float> cls2(a, b);     // 调用 myclass 模板类的第一种实现方法， 输出 m_var1: 10， m_var2: 15
    myclass cls1(c, d);             // 调用 myclass 模板类的第二种实现方法，输出 C D
}

以上例子的第二种 myclass 的实现方法展示了如何使用全部模板特定化，可以看到，其基础的语法格式为：

// 模板特定化定义方法
template<>   // <> 内不设置任何的参数
class ClassName <基础类型1，基础类型2>{}

当然，除了全部模板特定化，还可以只定义所有模板种的部分为特定的基础类型，编译器也会根据部分匹配来优先选择合适的模板函数。其基础语法如下：

// 部分模板特定化定义方法
// 例子1：部分参数特定化
template<typename T>   // <> 内设置自定义的参数类型
class ClassName <T, char>{};  	// 带有 char 类型的变量自动调用该类 
// 例子2：部分指针特定化
template<typename T>   // <> 内设置自定义的参数类型
class ClassName <T*>{};  // 指针变量则自动调用模板类

2. 可变参数模板

首先什么场景需要用到可变参数模板呢？如1.2中的例子，我需要初始化两个参数，所以，我们模板函数的写法为：

template <typename ctype, typename btype>       // 使用 template 关键字定义类型，可以同时定义多个类型

当我需要初始50个或者未知个数的参数时，这种方法就显得非常鸡肋了，因此引入可变参数模板，其基础语法为：

template <typename... Args>   // 其中 Args 代表参数类型的列表

因为不确定模板参数类型的个数有多少，因此常常通过递归调用的方法实现。以下通过一个函数和一个类展示其用法。

#include<iostream>
using namespace std;

// 2.1 可变参数模板函数
template <typename T>   // base case：当递归到最后一个元素时会调用该函数
T mysum(T t) {
  return t;
}

template <typename T, typename... ARGS>     // 可以适用于未知个数函数参数
T mysum(T t, ARGS... args){
    return t + mysum(args...);
}

// 2.2 可变参数模板类

template <typename... Types>
class myclass;

// 类似于函数，也需要额外定义 base case，即递归到空类
template <>
class myclass<>{};

template<typename Head, typename... Tail>
class myclass<Head, Tail...> : public myclass<Tail...>{
    public:
    myclass(Head head, Tail... tail) : myclass<Tail...>(tail...), head_(head){
        cout << head_ << endl;
    };

    private:
    Head head_;
};

int main(){
    cout << mysum(1, 2, 3, 4, 5, 6) << endl;  // output: 21
    myclass<int, float, double, int> cls(1, 2.0f, 3.0, 4);  // 当不显式设置参数类型时报错，无法自动推断，不解, output: 4, 3, 2, 1
}

3. 类型特征与模板函数

函数特征，通过头文件 #include<type_traits> 添加。其核心功能在判断输入变量是否属于某一个特定的类型，如：

#include<iostream>
#include<type_traits>
using namespace std;

int main(){
    int a = 10;
    cout << "is it a pointer? " << boolalpha << is_pointer<decltype(a)>::value <<endl;     // is it a pointer? false
    cout << "is it a arithmetic? " << boolalpha << is_arithmetic<decltype(a)>::value <<endl;  // is it a arithmetic? true
    cout << "is it a function? " << boolalpha << is_function<decltype(a)>::value <<endl;  // is it a function? false
}

那么这如何跟模板函数梦幻联动呢？通过 条件控制！

1. std::conditional<condition, A, B> ：如果条件为真，则使用模板类型A，否则使用类型B
2. std::enable_if<condition, A>：如果条件为真，则使用模板类型A，否则没有输入类型

#include<iostream>
#include<type_traits>
using namespace std;

template <typename T>
typename enable_if<is_arithmetic<T>::value, T>::type find_max(T a, T b){
    cout << "max value is: " << (a > b ? a : b) << endl;
};

template <typename T>
typename conditional<is_arithmetic<T>::value, T, char>::type find_max1(T a, T b){
    cout << "max value is: " << (a > b ? a : b) << endl;
}

int main(){
    int a = 10, b = 25;
    find_max(a, b);
    find_max1(a, b);
}