C++总结之template

函数模板

我们可以把函数模板当做一种特殊的函数，里面的参数类型可以是任意类型，这样的话我们就可以减少重复定义，从而让这个函数模板自动适应不同的参数类型，也就是说函数可以适应多种类型的参数，例如double、int或者类什么的。

C++为了实现上面的功能，引入了template这个概念。我们可以把template当成是一种特殊的类型参数，并且也可以在函数里当做参数传递，心里面把它当做int什么的就行了。

使用类型参数声明函数模板的格式如下所示:

template <class identifier> function_declaration;
template <typename identifier> function_declaration;    // 这里使用了typename 当做声明类型参数

上面声明函数模板的格式只有一处不同，那就是class和typename，在这里其实使用哪一种都没有区别，看自己喜欢就行，C++对此也没有做严格的区分；

为了更好的说明如何使用函数模板，便在举一个很形象的例子，那就是一个用来返回较大值的函数，具体写法如下所示:

template <typename T>
T GetMax(T a, T b)
    return a > b ? a : b;

在上面的短短几行代码中我们就创建了一个函数模板用来获取两个数之间较大的那个数，不难看出T在这里并没有指明具体的类型，在这我们仍然可以在心里把它当做普通变量处理，返回值也是T。

为了使用我们定义的函数模板，可以参照统一的函数模板调用格式：

 function_name<type> (parameters);    // type就是具体的类型，例如int、double这些，parameters就是函数里的参数，也是具体类型

所以，如果我们想要实现获取两个整形值里较大的那个，我们可以传入int这个类型之后调用GetMax函数，具体示例如下:

int x = 4;
int y = 2;

int max = GetMax<int> (x, y);    // max = 4

类模板

由于template声明的类型可以是任意类型，也就是使用的时候传入具体的类型就行。所以可以参考上面函数模板的例子构造类模板也是一样的，在使用这个类的时候传入具体的变量类型就行了。例如下面的类模板定义：

template <typename T>
class MyPair{
    T value[2];

    public:
        MyPair(T first, T second)
        {
            value[0] = first;
            value[1] = second;
        }
  };

类模板的示例代码中定义一个MyPair类，用来存储任意类型的两个元素，例如double，char，int等，下面我就给出两个示例，分别存储double和int类型的变量

MyPair<int> myInt(2, 3);    // 存储两个整型值
MyPair<double> myDouble(2.3, 3.43);    // 存储两个double值

模板类的成员函数也可以在类外定义，写法和函数模板的写法是一样的，具体示例如下所示：

template <class T>
class MyPair {
    T a, b;
  public:
    mypair (T first, T second)
      {a=first; b=second;}
    T Getmax ();
};

template <typename T>
T MyPair<T>::Getmax ()    // 在类外定义函数， 注意前面的写法和函数模板写法一致
{
  T retval;
  retval = a>b? a : b;
  return retval;
}

模板特化

如果我们想要为类模板定义一个不同的实现接口，并且要求需要将特定参数作为参数传递时，那么我们就可以将该模板特化；

为了更好地说明模板特化，还是举个简单的例子吧。假设我们定义一个类mycontainer，这个类可以存储一个任意类型的变量，并且这个类还有一个函数叫做increasement用来将存储的类型加一。并且，如果这个类存储的是一个char类型的时候，我们会发现这个类对于实现将其中的成员变量转换为大写的功能将更加方便，不妨将这个函数定义为ToUpper，因此，我们可以为char类型的类模板实现模板特化，具体的示例代码如下：

// 模板特化
#include <iostream>
using namespace std;

// 声明类模板:
template <typename T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {return ++element;}
};

// char类型的模板特化:
template <>
class mycontainer<char> {
    char element;
  public:
    mycontainer(char arg) {element=arg;}

    char ToUpper()
    {
      if ((element>='a')&&(element<='z'))
      element+='A'-'a';
      return element;
    }
};

对于上面的模板特化，我们需要几点，注意类模板和模板特化的区别和联系：

• 在类模板的前面加上template <>，这表明是模板特化，也就是是说模板特化都需要加上这句话；
• 还有一点就是类模板后面使用了<char>参数，这个特定参数表示我们将模板类特化程<char>类型；

template的其他用法

除了以template或者class关键字开头声明的表示类型的模板参数之外，template也可以具有其他类型的参数，例如int、double这些参数，就类似于一个函数中拥有多个参数，每个参数类型还不一样。为了更好的说明template的其他用法，不妨参考下面的示例代码，

#include <iostream>
using namespace std;

template<class T, int N>    // 这里除了含有class声明的类型之外，还拥有一个int类型
class mysequence {
    T memblock [N];
  public:
    void setmember(int x, T value);
    T getmember(int x);
};

template<class T, int N>
void mysequence<T,N>::setmember(int x, T value) {
  memblock[x]=value;
}

template<class T, int N>
T mysequence<T,N>::getmember(int x) {
  return memblock[x];
}

int main(){
  mysequence<int,5> myints;
  mysequence<double,5> myfloats;
  myints.setmember(0,100);
  myfloats.setmember(3,3.1416);
  cout << myints.getmember(0) << '\n';
  cout << myfloats.getmember(3) << '\n';
  return 0;
}