2-3 模版与泛型编程

1. 前言

我们知道声明变量时需要指明变量的类型，类型决定了变量的属性和表现。变量的类型可以是内置的类型，例如int、float、double等；也可以是自定义的类型，例如结构体和类。在2-2章中函数重载一节我们了解了同名函数、不同数量或类型的参数构成了函数重载的条件，编译器在调用重载函数时根据参数类型推导出最适配的函数调用。

但如果我们想实现一个函数，它的参数类型有很多种可能，那么为了适配所有的参数类型，我们需要编写很多很多个重载的函数。

那么能不能不指定函数参数的类型，即参数类型以泛型的型式定义呢？

答案是：能，C++支持编写函数模板和类模板，以支持函数和类的多样性。STL标准库中容器和方法基本都以模板的方式实现。

函数重载和模板均是静态多态的实现方式，此外在2-4章中详细介绍了可变参数模板，读者可在阅读到相应内容时进行呼应。

2. 函数模板

在不使用模板的情况下，我们定义一个函数需要按如下的方式声明：ret_type function_name (parameter list),即返回值类型函数名(参数列表)。当定义模板时，需要先声明变量类型的占位符，语法如下：

template <typename T>
或者
template <class T>
ret_type function_name (parameter list)

T是变量类型的占位符，在函数声明前增加模板定义，即可以在这个函数实现的任何位置使用T类型去定义变量，但需要注意的是T作为泛型参数时无法制定默认值(形参不能为空)。
举例，声明泛型T和模板函数，返回值为T类型，参数为两个T类型的const引用，函数实现为两个参数相加：

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

template <typename T>
T add(const T& a, const T& b)
{
    return a + b;
}

int main()
{
    int i = 1, j = 2;
    cout << "i + j = " << add(i, j) << endl;  // i + j = 3
    double x = 3.14, y = 5.27;
    cout << "x + y = "<< add(x, y) << endl;  // x + y = 8.41
    string s1 = "hello";
    string s2 = "world";
    cout << "s1 + s2 = "<<add(s1, s2)<<endl; // s1 + s2 = helloworld
    return 0;
}

通过函数模板中占位符的类型在函数实际调用时被指定，从而实现了一个接口根据不同类型的入参实现不同的功能——接口重用。

3. 类模版

与函数模板类似的，在类定义前声明泛型占位符，在类的定义中使用占位符去定义变量。当类在实例化对象时，需要指定模版中占位符的实际类型，例如：
定义一个模板类，它有两个泛型占位符，在类中定义STL中的map容器作为成员变量，并实现向map中插入数据和将map打印的方法。

#include <map>
#include <string>
#include <iostream>
using namespace std;
template <typename T1, typename T2>
class KVMap
{
private:
    map<T1, T2> kvMap;
public:
    void setValue(const T1 key, const T2 value)  // 向map中插入数据
    {
        kvMap.insert(make_pair(key, value));
    }
    void printMap()     // 打印map的key和value
    {
        for(auto iter = kvMap.begin(); iter != kvMap.end(); iter++)
        {
            cout<<iter->first<<"="<<iter->second<<"&";
        }
        cout<<endl;
    }
};

int main()
{
    KVMap<string, string> kvParams;  // 实例化对象时指明模板的类型
    kvParams.setValue("age", "25");
    kvParams.setValue("name", "Evila");
    kvParams.printMap();  // age=25&name=Evila&
    return 0;
}

3.1 类模板继承于类模板

类模板可以作为基类被继承，若派生类也为类模板，那么可以指定基类特定的类型，也可以使用派生类的泛型来指定基类。

// 以上节定义的类模板为基类
template <typename T1, typename T2>
class KVMap;

// 若派生类也为类模板，则可以用派生类的泛型来指定基类
template <typename T1, typename T2>
class KVMapOne : public KVMap<T1, T2> 
{
}

3.2 普通类继承于类模板

类模板可以作为基类被继承，若派生类为普通类，那么必须指明当前基类的类型。

// 以上节定义的类模板为基类
template <typename T1, typename T2>
class KVMap;

// 若派生类也为类模板，则可以用派生类的泛型来指定基类
class KVMapTwo : public KVMap<std::string, int> 
{
}

3.3 类模板继承于普通类

类模板继承于普通类时，与普通的继承并无区别。类模板作为派生类，根据继承权限获得基类中的成员访问。

4. 模板特化、偏特化与萃取机

4.1 模板全特化

通过上节可以认识到，模板在非特化情况下，占位符的类型是在实例化时指明的。但有时在实现模板类或模板函数时，需要对某个确定的类型进行特殊处理，即实现特定类型下的非通用行为。此时，我们需要对模板进行特化处理，若将所有的占位符特化为绝对类型，则视为模板的全特化。

举个例子：
1、首先定义一个模板类，这里直接引用第二节定义的KVMap模板类。
2、对模板中的两个占位符进行全特化实现，如特化为string和double。实现非通用行为：在打印double的值时，保留3位数字。

template <> // 不能省略，为了说明正在实现该类的特化版本
class KVMap <string, double>
{
private:
    map<string, double> kvMap;
public:
    void setValue(const string key, const double value)  // 向map中插入数据
    {
        kvMap.insert(make_pair(key, value));
    }
    void printMap()     // 打印map的key和value
    {
        for(auto iter = kvMap.begin(); iter != kvMap.end(); iter++)
        {
            cout<<iter->first<<"="<<setprecision(3)<<iter->second<<"&";  // value为double类型时，只输出3位长度
        }
        cout<<endl;
    }
};
int main()
{
    KVMap<string, double> kvParams;
    kvParams.setValue("age", 25.12345); 
    kvParams.printMap();  // age=25.1&
    return 0;
}

4.2 模板偏特化

若只对模板声明中的部分占位符进行特化处理，或对全部模板占位符进行修饰处理，则可称为模板的偏特化。

偏特化：特化部分占位符

#include <map>
#include <iostream>
#include <iomanip>
using namespace std;
template <typename T>
class KVMap <string, T>  // 该类具有两个模板占位符，一个被特化为string，第二个未特化
{
private:
  map<string, double> kvMap;
public:
  void setValue(const string key, const T value)  // 向map中插入数据
  {
      kvMap.insert(make_pair(key, value));
  }
  void printMap()     // 打印map的key和value
  {
      for(auto iter = kvMap.begin(); iter != kvMap.end(); iter++)
      {
          cout<<iter->first<<"="<<setprecision(3)<<iter->second<<"&";  // 只输出3位数字
      }
      cout<<endl;
  }
};
int main()
{
  KVMap<string, double> kvParams; // 实例化时确定模板类型
  kvParams.setValue("age", 25.12345);  
  kvParams.printMap();  // age=25.1&
  return 0;
}

偏特化：特化为指针、引用、其他模板类型，这类偏特化对模板做了某些限定，但仍保留了泛型的通用性。

template <typename T1, typename  T2>
class KVMap <T1 *,T2 *>
{
private:
  map<T1*, T2*> kvMap;
public:
  void setValue(T1* key, T2* value)  // 向map中插入数据
  {
      kvMap.insert(make_pair(key, value));
  }
  void printMap()     // 打印map的key和value
  {
      for(auto iter = kvMap.begin(); iter != kvMap.end(); iter++)
      {
          // key和value被偏特化为指针类型，输出变值时需要解引用
          cout<<(*iter->first)<<"="<<setprecision(3)<<(*iter->second)<<"&";
      }
      cout<<endl;
  }
};
int main()
{
  KVMap<string*, string*> kvParams; // 实例化时确定模板类型
  string key1 = "age";
  string value1 = "100";
  kvParams.setValue(&key1, &value1);
  kvParams.printMap(); // age=100&
  return 0;
}
// C++不支持模板函数的偏特化，事实上对模板函数进行重载可以视为"偏特化"。例如：
template <typename T1, typename  T2>
void func(T1 t1, T2 t2);    // 未特化的模板函数
template <typename T1>
void func(T1 t1, int t2);   // 同名函数，第二个参数为int类型，这其实是函数的重载

4.3 类型萃取机制

泛型类和方法在模板的支持下，可以支持多种多样的变量类型。若我们在编写模板类或模板函数时，对某个特殊类型需要实现特殊处理，可以选择性的使用全特化和偏特化实现。但如果模板类和模板函数需要实现很多不同类型的特殊性质，那么就需要编写多个特化副本。试想一下若有一个萃取机可以帮助判断传入的类型，那么就可以在一份实现中编写多个分支，去实现不同的特性。

总结概念：萃取是在模板类中萃取类型的某些特性，帮助判断该类型是否需要实现某些特性，从而在泛型方法中来对该类型进行特殊的处理的机制。

萃取机制的实现依靠于模板特化机制和typedef类型定义关键字。
举个例子：在讲述类模板案例中实现了模板类KVMap，类中依靠成员变量std::map容器实现了成员函数printMap()。如果我们希望在打印map中存储的数据时，对于value为float和double类型实现只保留3位小数的特性，就需要在打印函数中利用类型萃取机制来获得value的变量类型，从而做出特性动作。

#include <iostream>
#include <map>
#include <iomanip>
#include <string>
#include <vector>
using namespace std;

// 1. 首先实现两个自定义类型，分别代表 '是' float/double类型 和 '不是'float/double类型
struct __TrueFloatOrDoubleType  // '是'float/double类型
{
    bool get()
    {
        return true;   // 判断是float或double类型
    }
};
struct __FalseFloatOrDoubleType  // '不是'float/double类型
{
    bool get()
    {
        return false;  // 判断不是float或double类型
    }
};

// 2. 定义萃取机类型
template <class _Tp>
struct TypeTraits
{
    typedef __FalseFloatOrDoubleType   __IsFloatOrDoubleType;  // 对类型重命名，默认定义不是float或double类型
    __IsFloatOrDoubleType traits;
};
// 3. 对萃取机类实现特化是类型萃取的关键
template <>
struct TypeTraits<float>  // 萃取机模板特化类型为float
{
    typedef __TrueFloatOrDoubleType   __IsFloatOrDoubleType;  // 对类型重命名，定义为是float/double类型
    __IsFloatOrDoubleType traits;
};
template <>
struct TypeTraits<double>  // 萃取机模板特化类型为double
{
    typedef __TrueFloatOrDoubleType   __IsFloatOrDoubleType;  // 对类型重命名，定义为是float/double类型
    __IsFloatOrDoubleType traits;
};
// 4. KVMap中利用萃取机制在泛型方法中实现特性
template <typename T1, typename  T2>
class KVMap
{
private:
    map<T1, T2> kvMap;
public:
    void setValue(T1 key, T2 value)  // 向map中插入数据
    {
        kvMap.insert(make_pair(key, value));
    }
    void printMap()     // 打印map的key和value
    {
        for(auto iter = kvMap.begin(); iter != kvMap.end(); iter++)
        {
            // 这里用萃取机实现判断T2是否为float或double类型
            if (!TypeTraits<T2>().traits.get())
            {
                // 5. 关键点：TypeTraits<T2> 若T2是float或double，则编译器会选择TypeTraits的特化实现
                // 在TypeTraits的特化实现中，我们将__IsFloatOrDoubleType由typedef定义
                //__FalseFloatOrDoubleType得到，因此get()方***返回false
                // 在这个if分支中，T2的类型一定是float或double 因此打印时只输出3位小数
                cout<<iter->first<<"="<<setprecision(3)<<iter->second<<"&";
            }
            else
            {
                 // T2不是float或doube类型，打印时全部输出
                cout<<iter->first<<"="<<iter->second<<"&";
            }
        }
        cout<<endl;
    }
};
int main()
{
    KVMap<string, double> kvParams; // 实例化时确定模板类型
    string key1 = "age";
    double value1 = 100.12345;  
    kvParams.setValue(key1, value1);
    kvParams.printMap();  // age=100.123&
    return 0;
}

以上用一个小的案例介绍了萃取机制在模板类编写过程中的作用，事实上萃取机制在STL标准库中被广泛应用。STL标准库中提供了一系列容器模板和泛型方法，而容器迭代器是容器与方法之间沟通的桥梁，泛型方法希望了解到传入容器的数据类型、数据指针和引用类型、迭代器类型、元素间隔计算类型等。因此，对容器迭代器进行类型萃取是实现STL中泛型方法的重要一步。

// 在GNU2.9中关于迭代器萃取机iterator_traits的声明，iterator_traits能够根据传入的迭代器类型萃取出以下5种有关容器的类型。
template <class _Iterator>
struct iterator_traits {
  typedef typename _Iterator::iterator_category iterator_category;  // 迭代器的类型
  typedef typename _Iterator::value_type        value_type;     // 数据类型
  typedef typename _Iterator::difference_type   difference_type; // 距离类型   
  typedef typename _Iterator::pointer           pointer;     // 指针类型
  typedef typename _Iterator::reference         reference;    // 引用类型
};