前段时间重新学习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’;
　　}
　　特别注意：类，全局函数，类的成员函数都可以特化，但是只有类可以半特化，全局函数和类的成员函数不可以半特化。
　　//-------------------------------------------
　　//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()
　　{
　　}