c++模板

函数模板声明

template   < 类型形式参数表 >
类型  函数名 （ 形式参数表 ）
    {      语句序列
    }

函数模板定义由模板说明和函数定义组成

模板说明的类属参数必须在函数定义中至少出现一次

函数参数表中可以使用类属类型参数，也可以使用一般类型参数

#include <iostream.h>
template < typename  T >
//函数模板
T  max ( T  a , T  b )
{ return  a > b ? a : b ; }
void  main ( )
{ cout << " max ( 3 , 5 )  is  " << max ( 3 , 5 ) << endl ;
  cout << " max ( 'y' , 'e' )  is  " << max ( 'y' , 'e' ) << endl ;
  cout << " max ( 9.3 , 0.5 )  is  " << max ( 9.3 , 0.5 ) << endl ;
}

匹配约定

寻找和使用最符合函数名和参数类型的函数，若找到则调用它；

否则，寻找一个函数模板，将其实例化产生一个匹配的模板函数，若找到则调用它；

否则，寻找可以通过类型转换进行参数匹配的重载函数，若找到则调用它如果按以上步骤均未能找到匹配函数，则调用错误。

如果调用有多于一个的匹配选择，则调用匹配出现二义性。

template< typename T >
class  Array
{ public :
    Array ( int s ) ;
    virtual ~ Array () ;
    virtual const T& Entry( int index ) const ;
    virtual void Enter( int index, const T & value ) ;
  protected : 
int size ;
//数据成员是T类型指针
    T * element ;
} ;
//类模板的成员函数是函数模板
template<typename T> Array<T>::Array(int s)
  { if ( s > 1 ) size = s ;     else size = 1 ;
     element = new T [ size ] ;
  }
template < typename T > Array < T > :: ~Array()
  { delete [] element ; }
template < typename T > const T& Array < T > :: Entry ( int index ) const
  { return  element [ index ] ; }
template < typename T > void Array < T > :: Enter(int index, const T& value)
  { element [ index ] = value ; }

类模板作函数参数

函数的形式参数类型可以是类模板或类模板的引用，对应的实际参数是该类模板实例化的模板类对象，当一个函数拥有类模板参数时，这个函数必定是函数模板。

//一个用 Array<T> 作参数的函数模板
template < typename T >
void  Tfun( const Array <T> & x , int index )
   { cout << x.Entry( index ) << endl ; } 

//调用函数模板
Array <double> DouAry( 5 ) ;// 调用构造函数，实例化模板类，建立对象 
…
Tfun(DouAry,3); 

一个类模板在类层次结构中既可以是基类也可以是派生类：

 类模板可以从模板类派生

 类模板可以从非模板类派生

 模板类可以从类模板派生

 非模板类可以从类模板派生

//从类模板Array<T>派生一个安全数组类模板BoundArray<T>
template< typename T >
class  Array
{ public :
    Array ( int s ) ;    virtual ~ Array () ;
    virtual const T& Entry( int index ) const ;
    virtual void Enter( int index, const T & value ) ;
  protected : 
    int size ;    T * element ;
} ;
template < typename T >
class BoundArray : public Array < T >
{ public :
      BoundArray ( int low = 0, int height = 1 ) ;
      virtual  const T& Entry ( int  index ) const ;
      virtual  void Enter ( int  index , const T& value ) ;
    private: int  min ;
} ; 

类模板派生普通类，在定义派生类时要对基类的抽象类参数实例化，从普通类派生模板类，意味着派生类添加了抽象类数据成员。

//从类模板A派生普通类B
#include<iostream.h>
template< typename T >	//定义类模板
class  A
{ public :
       A( T x ) { t = x ; }
       void out() { cout << t << endl ; }
  protected : 
      T t ;
} ;
class B: public A<int>	//派生一般类
{ public :// 实例化基类抽象类型参数
       B ( int a,  double x ) : A <int> ( a ) { y = x ; }
       void out() { A <int> :: out() ;  cout << y << endl ; }
  protected :
      double y ;
};

在类模板中可以声明各种友员关系

一个函数或函数模板可以类是或类模板的友员

一个类或类模板可以是类或类模板的友员类

声明这种模板之间的友员关系符号比较烦琐

template <typename T> class X
{ //……
     friend void f1();
}//函数f1成为类模板X实例化的每个模板类的友员函数

 template <typename T> class X
{ //……
     friend void f2( X<T> & );
}//对特定类型（如double），使模板函数f2(X<double>&)成为X<double>的友员
 template <typename T> class X
{ //……
     friend void A::f3();
} //A类的成员函数f3成为类模板X实例化的每个模板类的友员函数
template <typename T> class X
{ //……
     friend void B<T>::f4( X<T> & );
}//对特定类型（如double），使模板类B<double>的成员函数f4(X<double>&)成为模板类X<double>的友员
 template <typename T> class X
{ //……
     friend class Y;
}//Y类的每个成员函数成为类模板X实例化的每个模板类的友员函数
template <typename T> class X
{ //……
     friend class Z<T>;
}//对特定类型（如double），使模板类Z<double>所有成员函数成为模板类X<double>的友员