C++模板

• 函数模板

template <typename T>
void swap(T & a, T & b)
{
   T temp=a;
    a=b;
    b=temp;
}

• 类模板
  template //关键字template定义一个模板,Type是一个通用的类型说明符
  或者template
  例子：

template class <typename Type>
 class Stack
 {
    private:
          enum {MAX=10};
          Type items[MAX];
          int top;
    public:
         Stack();
         bool push(const Type & item); 
 };

• 模板成员函数的实现：

template <class Type>
bool Stack<Type>::push(const Type & item)
{
  if(top<MAX)
  {
     items[top++]=item;
     return true;
  }else
  return false;
}

• 使用模板类

Stack<int> inters;
Stack<string> strs;

• 数组模板

template <class T, int n>
class ArrayTp
{
private:
    T ar[n];
public:
   ArrayTp() {};
   explicit ArrayTp(const T & v);
   virtual T & operator[] (int i);
};
template <class T,int n>
ArrayTp<T,n> :: ArrayTp(const T & v)
{
   for(int i=0;i<n;i++)
     ar[i]=v;
}

• 成员模板
  用作结构、类或模板类的成员

#include <iostream>
using namespace std;
template <typename T>//定义类模板
class beta
{
    private:
        template <typename V>//成员类
        class hold
        {
            private:
                V val;
            public:
                hold (V v=0): val(v) {}
                void show() const {cout<<val<<endl;}
                V Value() const {return val;}

        };
        hold<T> q;
        hold<int> n;
    public:
        beta(T t,int i):q(t),n(i) {}
        template <typename U>//模板函数
        U blab(U u,T t) {return (n.Value()+q.Value())*u/t;}
        void Show() const {q.show();n.show();}
};
int main()
{
    beta<double> guy(3.5,3);
    guy.Show();
    cout<<guy.blab(10,2.3)<<endl;//U double
    cout<<guy.blab(10.0,2.3)<<endl;//U int
    return 0;
 } 

//如果编译器接受类外面的定义，可以在beta模板之外定义模板方法

#include <iostream>
using namespace std;
template <typename T>
class beta
{
    private:
        template <typename V>
        class hold;
        hold<T> q;
        hold<int> n;
    public:
        beta(T t,int i):q(t),n(i) {}
        template <typename U>
        U blab(U u,T t); 
        void Show() const {q.show();n.show();}
};
//成员定义
template <typename T>
  template<typename V> 
    class beta<T>:: hold
        {
            private:
                V val;
            public:
                hold (V v=0): val(v) {}
                void show() const {cout<<val<<endl;}
                V Value() const {return val;}

        };

//成员定义
template <typename T>
  template<typename U> 
    U beta<T>:: blab(U u,T t)   
    {return (n.Value()+q.Value())*u/t;} 
int main()
{
    beta<double> guy(3.5,3);
    guy.Show();
    cout<<guy.blab(10,2.3)<<endl;
    cout<<guy.blab(10.0,2.3)<<endl;
    return 0;
 } 

• 模板包含的参数本身是模板

template <template <typename T> class Thing>
class Crab
{
  private:
    Thing<int> s1;
    Thing<int> s2;
  public:
    Crab() {};
    bool push(int a, double x)
    {return s1.push(a)&&s2.push(x);}
    bool pop(int a, double x)
    {return s1.pop(a)&&s2.pop(x);}
};
int main()
{
   ...
   Crab<Stack> s;//Stack类要与thing类匹配
}

template < typename T> class Thing中template < typename T> class是类型，Thing是参数。假设有下面的声明‘Crab< Stack> s; ‘这个声明要想被接受，必须与Stack模板类的声明匹配。Crab类可以使用与Thing 类型声明匹配。Crab类对thing类做了以下假设：这个类包含push方法，pop方法，且這些方法需包含接口。