//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';
}

//-------------------------------------------
//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()
{
}