c++泛型编程与模板-01函数模板

函数模板的定义

所谓函数模板，实际就是写一个通用函数，返回值和参数的类型都是可变的，用一个特定格式的变量来指定，然后调用此函数的时候，编译器会根据参数的数据类型自动推导出类型，从而达到函数再不同的类型参数下可复用的目的。这个通用函数就是函数模板，使用模板就无须关心数据类型，只定义一个函数模板就可以。
定义函数模板的语法格式如下所示：

template<typename 类型占位符> 
返回值类型 函数名(参数列表)
{
    //函数体;
}

其中：template 是声明模板的关键字，<>中的参数称为模板参数；typename 关键字用于标识模板参数，可以用class关键字代替，class 和 typename 并没有区别。模板参数不能为空，一个函数模板中可以有多个模板参数，模板参数和普通函数参数相似。template下面是定义的函数模板，函数模板定义方式与普通函数定义方式相同，只是参数列表中的数据类型要使用<>中的参数名表示。

函数模板实例化

函数模板并不是一个函数，它相当于一个模子，定义一次即可使用不同类型的参数来调用该函数模板，这样做可以减少代码的书写，提高代码的复用性和效率。函数模板不会减少可执行程序的大小，因为编译器会根据调用时的参数类型进行相应的实例化。所谓实例化，就是用类型参数替换模板中的模板参数，生成具体类型的函数。实例化可分为隐式实例化与显式实例化。

Example01

#include <iostream>

// 定义函数模板
template <typename T>
T my_add(T t1, T t2)
{
    return t1 + t2;
}

int main(int argc, char** argv)
{
    std::cout << my_add(1, 2) << std::endl;      // 传入int类型参数
    std::cout << my_add(1.0, 2.0) << std::endl;  // 传入double类型参数
    return 0;
}

隐式实例化

隐式实例化是根据函数调用时传入的参数的数据类型确定模板参数 T 的类型，模板参数的类型是隐式确定的.
在Example01中第一次调用my_add()函数模板时传入的是int类型的数据1、2，编译器根据传入的实参推演出模板参数类型是int，就会根据函数模板实例化出一个int类型的函数，如下所示：

int my_add(int t1, int t2)
{
    return t1 + t2;
}

编译器生成具体类型函数的这一过程就称为实例化，生成的函数称为模板函数。生成int类型的函数后，再传入实参1和2进行运算。
同理，当传入 double 类型的数据时，编译器先根据模板实例化出如下形式的函数：

double my_add(double t1, double t2)
{
    return t1 + t2;
}

这样，每一次调用时都会根据不同的类型实例化出不同类型的函数，最终的可执行程序的大小并不会减少，只是提高了代码的复用性。

显示实例化

隐式实例化不能为同一个模板参数指定两种不同的类型，这就需要显式实例化解决类型不一致的问题。显式实例化需要指定函数模板中的数据类型，语法格式如下所示：

template函数返回值类型 函数名<实例化的类型>(参数列表);

在Example01中,显示实例化为 int 类型，则在调用时，不是 int 类型的数据会转换为int类型再进行计算.

#include <iostream>

// 定义函数模板
template <typename T>
T my_add(T t1, T t2)
{
    return t1 + t2;
}

template int my_add<int>(int t1, int t2);  // 显示实例化为int类型

int main(int argc, char** argv)
{
     // 函数模板调用
     // 在调用int类型函数模板时，传入一个字符'a',则编译器会将字符类型'a'转换为ASCII码值，然后在与1相加得出结果
    std::cout << my_add<int>(1, 'a') << std::endl; 
    std::cout << my_add(1.0, 2.0) << std::endl;

    return 0;
}

需要注意的是，对于给定的函数模板，显式实例化声明在一个文件中只能出现一次，并且在这个文件中必须给出函数模板的定义。

显示具体化

函数模板的显式具体化是对函数模板的重新定义，具体格式如下所示：

template<> 函数返回值类型 函数名<实例化类型>(参数列表)
{
    //body
}

Example02
定义交换两个数据的函数模板，示例代码如下:

template<typename T>
void my_swap(T &t1, T &t2)
{
    T temp = t1;
    t1 = t2;
    t2 = temp;
}

但现在有如下结构体定义，示例代码如下：

struct Student
{
    uint64_t id;
    float    score;
    char     name[40];
};

现在想交换2个学生的id，但是又不想交换姓名、成绩等其他信息，则可以用显示具体化方式重新定义函数模板，只需交换结构体的部分成员变量即可。则该显示具体化如下所示：

template <>
void my_swap<Student>(Student& t1, Student& t2)
{
    int temp = t1.id;
    t1.id    = t2.id;
    t2.id    = temp;
}

如果函数有多个原型，则编译器在选择函数调用时，非模板函数优先于模板函数，显式具体化模板优先于函数模板.例如下面三种定义：

void my_swap(int&, int&);                         //直接定义
template<typename T>void my_swap(T& t1, T& t2);   //模板定义
template<> void my_swap<int>(int&, int&);         //显式具体化

对于int a,int b,在调用my_swap(a, b)时，则优先调用直接定义的函数；如果没有则优先调用显示具体化，如果2者都没有才会调用函数模板。

函数模板重载

函数模板可以进行实例化，以支持不同类型的参数，不同类型的参数调用会产生一系列重载函数。
在Example01中两次调用my_add() 函数模板，编译器会根据传入参数不同实例化出两个函数，如下所示：

int my_add(int t1, int t2)  // int 类型参数实例化出的函数
{
    return t1 + t2;
}

double my_add(double t1, double t2)// double 类型参数实例化出的函数
{
    return t1 + t2;
}

函数模板本身也可以被重载，即名称相同的函数模板可以具有不同的函数模板定义，当进行函数调用时，编译器根据实参的类型与个数决定调用哪个函数模板实例化函数。

#include <iostream>
int my_max(const int& a, const int& b)  // 非模板函数，求两个int类型数据的较大值
{
    return a > b ? a : b;
}

template <typename T>  // 定义求两个任意类型数据的较大值
T my_max(const T& t1, const T& t2)
{
    return t1 > t2 ? t1 : t2;
}

template <typename T>  // 定义求三个任意类型数据的最大值
T my_max(const T& t1, const T& t2, const T& t3)
{
    return my_max(my_max(t1, t2), t3);
}

int main(int argc, char** argv)
{
    std::cout << my_max(1, 2) << std::endl;      // 调用非模板函数
    std::cout << my_max(1, 2, 3) << std::endl;   // 调用三个参数的函数模板
    std::cout << my_max('a', 'e') << std::endl;  // 调用两个参数的函数模板
    std::cout << my_max(6, 3.2) << std::endl;    // 调用非模板函数
    return 0;
}

注意，模板不允许自动类型转化，如果有不同类型参数，只允许使用非模板函数，因为普通函数可以进行自动类型转换。

函数模板使用的注意项

• <>中的每一个类型参数在函数模板参数列表中必须至少使用一次

  template<typename T1, typename T2>
  void func(T1 t)
  {
  }
  

• 全局作用域中声明的与模板参数同名的对象、函数或类型，在函数模板中将被隐藏

  int num;
  template<typename T>
  void func(T t)
  {
      T num;
      cout<<num<<endl;  //输出的是局部变量num，全局int类型的num被屏蔽
  }
  

• 函数模板中声明的对象或类型不能与模板参数同名

    template<typename T>
    void func(T t)
    {
        typedef float T;  //错误，定义的类型与模板参数名相同
    }
  

• 模板参数名在同一模板参数列表中只能使用一次，但可在多个函数模板声明或定义之间重复使用

    template<typename T, typename T>  //错误，在同一个模板中重复定义模板参数
    void func1(T t1, T t2){}
  
    template<typename T>
    void func2(T t1){}
    
    template<typename T>   //在不同函数模板中可重复使用相同的模板参数名
    void func3(T t1){}
  

• 模板的定义和多处声明所使用的模板参数名不是必须相同

  //模板的前向声明
  template<typename T>
  void func1(T t1, T t2);
  
  //模板的定义
  template<typename U>
  void func1(U t1, U t2)
  {
  }
  

• 如果函数模板有多个模板参数，则每个模板参数前都必须使用关键字 class 或 typename 修饰

  template<typename T, typename U>  //两个关键字可以混用
  void func(T t, U u){}
  
  template<typename T,U>   //错误，每一个模板参数前都必须有关键字修饰
  void func(T t, U u){} 
  

可以定义模板参数的默认值,这些值被称为默认模板参数，它们可以与任何类型的模板一起使用。默认模板参数甚至可以引用在它之前声明的模板参数。当默认模板参数和模板参数自动推导结合起来使用时，可以指定函数中的一部分模板参数采用默认参数，而另一部分使用自动推导。模板参数的填充顺序是从左到右

#include <iostream>

template <typename R = int, typename U>
R my_func(U val)
{
    std::cout << typeid(val).name() << std::endl;
    return val;
}

int main(int argc, char** argv)
{
    auto res1 = my_func(123.0);// 默认模板参数和模板参数自动推导结合:R->默认模板参数 int类型,U->模板参数自动推导(double),在隐士转换为int
    auto res2 = my_func<long>(123); // 模板参数的填充顺序是从左到右,R->long U->根据参数123(int)隐士推导为int
    if (typeid(res1) == typeid(int)) {
        std::cout << "my_func(123) return int type" << std::endl;
    }

    if (typeid(res2) == typeid(long)) {
        std::cout << "my_func<long>(123) return long type" << std::endl;
    }

    return 0;
}