C++模版全掌握（实例）

C++模版全掌握（实例）

前段时间重新学习C++，主要看C++编程思想和C++设计新思维。对模版的使用有了更进一层的了解，特总结如下：

下面列出了模版的常用情况：

// 1. 模板类静态成员
template  < typename T >   struct  testClass 
{ 
    static int _data; 
} ; 
template <>   int  testClass < char > ::_data  =   1 ; 
template <>   int  testClass < long > ::_data  =   2 ; 
int  main(  void  )  { 
    cout << boolalpha << (1==testClass<char>::_data) << endl; 
    cout << boolalpha << (2==testClass<long>::_data) << endl; 
}  

// 2. 模板类偏特化 
template  < class  I,  class  O >   struct  testClass 
{ 
    testClass() { cout << "I, O" << endl; } 
} ; 
template  < class  T >   struct  testClass < T * , T *>  
{ 
    testClass() { cout << "T*, T*" << endl; } 
} ; 
template  < class  T >   struct  testClass < const  T * , T *>  
{ 
    testClass() { cout << "const T*, T*" << endl; } 
} ; 
int  main(  void  ) 
{ 
    testClass<int, char> obj1; 
    testClass<int*, int*> obj2; 
    testClass<const int*, int*> obj3; 
}  

// 3.类模版+函数模版
template  < class  T >   struct  testClass 
{ 
    void swap( testClass<T>& ) { cout << "swap()" << endl; } 
} ; 
template  < class  T >  inline  void  swap( testClass < T >&  x, testClass < T >&  y ) 
{ 
    x.swap( y ); 
}  
int  main(  void  )
{ 
    testClass<int> obj1; 
    testClass<int> obj2; 
    swap( obj1, obj2 ); 
}  


// 4. 类成员函数模板 
struct  testClass
{ 
    template <class T> void mfun( const T& t )
    { 
        cout << t << endl; 
    } 
    template <class T> operator T() 
    { 
        return T(); 
    } 
} ; 
int  main(  void  ) 
{ 
    testClass obj; 
    obj.mfun( 1 ); 
    int i = obj; 
    cout << i << endl; 
}  

// 5. 缺省模板参数推导 
template  < class  T >   struct  test 
{ 
    T a; 
} ; 
template  < class  I,  class  O = test < I >   >   struct  testClass 
{ 
    I b; 
    O c; 
} ; 

void  main()
{
}


// 6. 非类型模板参数 
template  < class  T,  int  n >   struct  testClass  { 
    T _t; 
    testClass() : _t(n) { 
    } 
} ; 
int  main(  void  )  { 
    testClass<int,1> obj1; 
    testClass<int,2> obj2; 
}  


// 7. 空模板参数 
template  < class  T >   struct  testClass; 
template  < class  T >   bool   operator == (  const  testClass < T >& ,  const  testClass < T >&  ) 
{ 
    return false; 
} ; 
template  < class  T >   struct  testClass 
{ 
    friend bool operator== <>( const testClass&, const testClass& ); 
} ; 
void  main()
{
}

// 8. template template 类
struct  Widget1 
{ 
template<typename T> 
    T foo(){} 
} ; 

template < template < class  T > class  X >  
struct  Widget2
{ 
} ; 
void  main()
{
    cout<< 3 << '\n';
}

//参考： http://www.cnblogs.com/dayouluo/archive/2005/05/14/155092.html

特别注意：类，全局函数，类的成员函数都可以特化，但是只有类可以半特化，全局函数和类的成员函数不可以半特化。

// -------------------------------------------
// 1 类的特化和类成员函数的特化
template < typename T >
class  Widget1
{
public:
    void Fun1()
    {
        //generic implementation
    }
    
} ;

template <>
class  Widget1 < int >
{
public:
    void Fun1()
    {
    }
} ;
template <>  
void  Widget1 < char > ::Fun1()
{
    //specialization
}

void  main()
{ 

  Widget1<char> w;
  w.Fun1();
  Widget1<int> w2;
  w2.Fun1();
  
}
// -------------------------------------------
// 2 全局函数的特化和重载
template < typename T1, typename T2 >
T1 Fun2(T2)
{
}

// 下面2个应该是属于重载
template < typename T2 >
char  Fun2(T2)
{
    char c;
    return c;
}

template < typename T1 >
T1 Fun2( char )
{
}

// 全局函数的特化
template <>
char  Fun2 < char , int > ( int )
{
    char c;
    return c;
}
int  main()
{
}
// -------------------------------------------
// 3 全局函数不能半特化，以下编译失败
template  < typename T1,typename T2 >   // 原型1
void  Test(T1,T2)
{
}

template  < typename T1 >
void  Test < T1,T1 > (T1,T1)
{
}

template < typename T1, typename T2 >   // 原型2
T1 Fun2(T2)
{
}
//
template < typename T2 >
int  Fun2 < int ,T2 > (T2)
{
}
template < typename T1 >
T1 Fun2 < T1, int > ( int )
{
}
template < typename T >
T Fun2 < T,T > (T)
{
}
int  main()
{
}


/**/ ////-------------------------------------------
////4 类可以特化和半特化，但是特的成员函数像全局函数一样，只能特化，不能半特化，
template < typename T1, typename T2 >   struct  Widget2
{
  void Fun2()
  {
      //generic implementation
  }
} ;

template < typename T2 >  
struct  Widget2 < char ,T2 >
{
    void Fun2()
    {
    }
} ;

template < typename T2 >
struct  widget2
{
    void Fun2()
    {
        // class partial specialization
    }
} ;



// the class member funtion can not be partial specialization
// 以下的成员函数半特化，编译失败
template < typename T2 >
void  Widget2 < char , T2 > ::Fun2()
{
    //class member function partial specialization
}
int  main()
{
}

参考：C++编程思想2