C++ 模板

0.前言

模板是一种通用的描述机制，当使用模板时，允许使用通用类型来定义函数或类。通用类型可被具体类型（如int,double甚至是用户自定义类型）来代替。模板引入了一个全新的编程思维方式，称为“泛型编程”或者“通用编程”。

1.函数模板

1）函数模板声明形式如下：

template  <class(或typename) A,...,int B (常数)>
返回类型   函数名（参数列表）
{
    //函数体
}

class用于定义类，在模板引入c++后，最初定义模板的方法为：template<class T>，这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字，它的作用同class一样表明后面的符号为一个类型。

2)函数模板的使用

函数模板定义形式如下：

template  <class T1[,  class T2, ......]>
函数原型;

3)函数模板实例化

3.1)隐式实例化：

/*************************main.c********************/
#include <iostream.h>
using namespace std;
template<class Ex>
Ex  Greater(Ex x,Ex y);

int main()
{
    int inx=1;iny=2;
    cout<<Greater(inx,iny)<<endl;   //实参为int类型，生产int型模板函数，并对第二个进行实参检查
    return 0;
}

template<class Ex>
Ex  Grearer(Ex x,Ex y)
{
    return x>y?x:y;
}

输出结果如下为2;

3.2)显示实例化标准格式如下：

template  返回类型   函数名<类型实参表>  （函数参数表）

/*************************main.c********************/
#include <iostream.h>
using namespace std;
template<class Ex>
Ex  Greater(Ex x,Ex y);

template  int  Greater<int>  (int,int);

int main()
{
    int inx=1;iny=2;
    cout<<Greater(inx,iny)<<endl;   //调用实例化模板函数
    return 0;
}

template<class Ex>
Ex  Grearer(Ex x,Ex y)
{
    return x>y?x:y;
}

3.3)利用特化可以解决某些类型在函数中的特殊操作，特化的基本格式如下：

template<>  返回类型  函数名[(类型实参表)]（函数参数表）

其中类型实参表可以省略，有后续的函数参数表来指定。

/*************************main.c********************/
#include <iostream.h>
using namespace std;
template<class Ex>
Ex  Greater(Ex x,Ex y);

template<>  double  Greater<double>(double,double);   //特化声明

int main()
{
    int inx=1;iny=2;
    double dbx = 3.0,dby = 2.9;
    cout<<Greater(inx,iny)<<endl;      //隐式实例化
    cout<<Greater(dbx,dby)<<endl;    //优先调用特化函数
    return 0;
}

template<class Ex>
Ex  Grearer(Ex x,Ex y)
{
    return x>y?x:y;
}

template<>  double  Greater(double x,double y)   //特化定义
{
    return x+y;
}

输出结果为：

2
5.9

3.4)优先级和执行顺序

一般函数的执行顺序优先于模板的特化函数，模板的特化函数优先于实例化函数。

更特化的含义体现在“编译器做决定是执行的转换最少”，c++遵循部分排序规则来选择最优化模板函数。

template<class T>  void  f(T) {}        #1
template<class T>  void  f(T*) {}        #2
template<class T>  void  f(const T*) {}        #3
template<class T>  void  g(T) {}        #4
template<class T>  void  g(T&) {}        #5

int main()
{
    const int *p;
    f(p);
    int q;
    //g(q);
}

模板#2比模板1更特化，模板3比模板2更特化，因此f(p)调用#3。然而模板#4和#5没有谁比谁更特化，因此g（q）会带来二义性错误。

2.类模板

1)类模板的定义

template<class 模板参数表>
class 类名｛
    // 类定义
｝；

2)类模板实例化

2.1)隐式实例化

首先定义类模板：

template  <class T,int num>
class Stack
{
    private:
        T  sz[num];
        int point;
    public:
        Stack();
        ...
}

template<class T,int num>
Stack<T,num>::Stack()
{
    point = 0;
}

然后使用一下语句隐式实例化：

Stack<int,10> st;

下述语句不需要创建对象，编译器不会隐式生成类定义：

Stack<int,10> *ps;

2.2)显示实例化

template  class 类名<类型参数表>

2.3)显示特化

template<>  class 类名<特殊类型>
{
     类定义；
}

2.4)部分特化

template<class T1 , class T2> class Example
{
   //类定义
}；
部分特化定义为：
template<class T2> class Example<int ,T2>
{
   //类定义
}

3)模板的嵌套

3.1)函数成员模板

成员模板不能声明为虚函数。

#include <iostream.h>
using namespace std;
template<class A>
class Test
{
    public:
        template<class B>
         A f(B);
};

template<class A>
template<class B>
A Test<A>::f(B)
{
   return A(B);
}

int main()
{
    Test<int> t;
    cout<<t.f(3.14)<<endl;
    return 0;
}

输出结果是：3

3.2)对象成员模板

类模板的定义可以放在另一个类中，实例化后的模板对象可以作为另一个类的成员。

#include <iostream.h>
using namespace std;
template<class T>
class Outside
{
    public:
        template<class R>
        class Inside
        {
             private:
                  R r;
             public:
                  Inside(R r)     //类模板的成员函数可以在定义时实现
                  {
                      r = x;
                   }
             void disp();
        };
       void disp();
     private:
          Inside<T> t;
} ;

template<class T>
template<class R>
void Outside<T>::Inside<R>::disp()    //类模板的成员函数也可以在定义外实现
{
    cout<<"Inside: "<<Outside<T>::Inside<R>::r<<endl;
}

template<class T>
void  Outside<T>::disp()
{
    cout<<"Outside:";
   t.disp();
}

int main()
{
    Outside<int>::Inside<double> obin(3.5);  //声明Inside类对象
    obin.disp();
    Outside<int> obout(2);                          //创建Outside对象obout
    obout.disp();
    return 0;
}

输出结果如下：

Inside：  3.5
Outside:Inside:  2

4)模板参数

模板可以作为另一个模板的参数类型，形式如下：

template<template <class T1> class T2,class T3,int Num>;

#include <iostream>
using namespace std;

template<class T,int num>
class Stack
{
    private:
         T sz[num];
    public:
         int ReturnNum();  
};
template<class T1,int num1>
int Stack(T1,num1>::ReturnNum()
{
     return num1;
}

template<template<class Type,int NUM> class TypeClass,class T1,int N>
void  disp()
{
     TypeClass<T1,N> ob;     //类模板的隐式实例化，创建对象ob
     cout<<ob.ReturnNum()<<endl;
}

int main()
{
   disp<Stack,int,8>();
   return 0;
}

输出结果为：8。