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 ;

特别注意：类，全局函数，类的成员函数都可以特化，但是只有类可以半特化，全局函数和类的成员函数不可以半特化。
// -------------------------------------------
// 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)
{