C++—模板（2）类模板与其特化

我们以顺序表为例来说明，普通顺序表的定义如下：

 typedef int DataType;
 //typedef char DataType;
 class SeqList
 {
 private :
 DataType* _data ;
 int _size ;
 int _capacity ;
 } ;

模板类也是模板，必须以关键字templ ate开头，后接模板形参表。模板类一般格式如下：
template<class 形参名 1, class 形参名 2, . . . class 形参名 n>
class 类名
{ . . . } ;

 // 以模板方式实现动态顺序表
 template<typename T>
 class SeqList
 {
 public :
 SeqList() ;
 ~ SeqList() ;
 private :
 int _size ;
 int _capacity ;
 T* _data ;
 } ;
 template <typename T>
 SeqList <T>: : SeqList()
 :
 _size()
 , _capacity()
 , _data(new T[ _capacity] )
 {}//注意模板类的类型不是SeqList
 template <typename T>
 SeqList <T>: : ~ SeqList()
 {
 delete [] _data ;
 }
 void test1()
 {
 SeqList<int > sl1;
 SeqList<double > sl2;
 }

【模板类的实例化】
只要有一种不同的类型，编译器就会实例化出一个对应的类。
SeqList<int > sl1;
SeqList<double > sl2;
当定义上述两种类型的顺序表时，编译器会使用int和double分别代替模板形参，重新编写SeqList类，最后创建名为SeqList<int>和SeqList<double>的类。

模板参数--实现容器适配器

 template <typename T>
 class SeqList
 {p
 rivate :
 int _size ;
 int _capacity ;
 T* _data ;
 } ;
 // template <class T, class Container>
 template <class T, class Container = SeqList<T> > // 缺省参数
 class Stack
 {
 public :
 void Push (const T& x) ;
 void Pop () ;
 const T& Top() ;
 bool Empty () ;
 private :
 Container _con ;
 } ;
 void Test()
 {
 Stack<int> s1;
 Stack<int , SeqList<int>> s2 ;
 // 思考下面这种使用场景会怎样？
 Stack<int , SeqList<char>> s3 ;
 }

为了避免上述问题的存在用下面的方法：

模板的模板参数--容器适配器

 template <typename T>
 class SeqList
 {p
 rivate :
 int _size ;
 int _capacity;
 T* _data ;
 } ;
 // template <class T, template<class> class Container>
 template <class T, template<class> class Container = SeqList> // 缺省参数
 class Stack
 {
 public :
 void Push(const T& x ) ;
 void Pop() ;
 const T& Top() ;
 bool Empty() ;
 private :
 Container<T > _con;
 } ;
 void Test()
 {
 Stack<int> s1;
 Stack<int , SeqList> s2;
 }

非类型的类模板参数

 // 静态顺序表
 //template<typename T, size_t MAX_SIZE>
 template <typename T, size_t MAX_SIZE = > //带缺省模板参数
 class SeqList
 {
 public :
 SeqList() ;
 private :
 T _array [MAX_SIZE] ;
 int _size ;
 } ;
 template <typename T, size_t MAX_SIZE>
 SeqList <T, MAX_SIZE>: : SeqList()
 : _size()
 {}
 void Test()
 {
 SeqList<int> s1;
 SeqList<int , > s2;
 }

注意：浮点数和类对象是不允许作为非类型模板参数的。

类模板的特化

类模板的特化：与函数模板类似，当类模板内需要对某些类型进行特别处理时，使用类模板的特化。例如：

 // general version
 template<class T>
 class Compare
 {
 public:
     static bool IsEqual(const T& lh, const T& rh)
     {
         std::cout <<"in the general class..." <<std::endl;
         return lh == rh;
     }
 };
 // specialize for float
 template<>
 class Compare<float>
 {
 public:
     static bool IsEqual(const float& lh, const float& rh)
     {
         std::cout <<"in the float special class..." <<std::endl;
 
         return std::abs(lh - rh) < 10e-;
     }
 };
 // specialize for double
 template<>
 class Compare<double>
 {
 public:
     static bool IsEqual(const double& lh, const double& rh)
     {
         std::cout <<"in the double special class..." <<std::endl;
 
         return std::abs(lh - rh) < 10e-;
     }
 };
 int main(void)
 {
     Compare<int> comp1;
     std::cout <<comp1.IsEqual(, ) <<std::endl;
     std::cout <<comp1.IsEqual(, ) <<std::endl;
 
     Compare<float> comp2;
     std::cout <<comp2.IsEqual(3.14, 4.14) <<std::endl;
     std::cout <<comp2.IsEqual(, ) <<std::endl;
 
     Compare<double> comp3;
     std::cout <<comp3.IsEqual(3.14159, 4.14159) <<std::endl;
     std::cout <<comp3.IsEqual(3.14159, 3.14159) <<std::endl;
     return ;
 }

全特化

还是以顺序表为例说明

 全特化
 template <typename T>
 class SeqList
 {
 public :
 SeqList() ;
 ~ SeqList() ;
 private :
 int _size ;
 int _capacity ;
 T* _data ;
 } ;
 template<typename T>
 SeqList <T>: : SeqList()
 : _size()
 , _capacity()
 , _data(new T[ _capacity] )
 {
 cout<<"SeqList<T>" <<endl;
 }
 template<typename T>
 SeqList <T>: : ~ SeqList()
 {
 delete[] _data ;
 }
 template <>
 class SeqList <int>
 {
 public :
 SeqList(int capacity) ;
 ~ SeqList() ;
 private :
 int _size ;
 int _capacity ;
 int* _data ;
 } ;
 // 特化后定义成员 函数不再需要模板形参
 SeqList <int>: : SeqList(int capacity)
 : _size()
 , _capacity(capacity )
 , _data(new int[ _capacity] )
 {
 cout<<"SeqList<int>" <<endl;
 }
 // 特化后定义成员 函数不再需要模板形参
 SeqList <int>: : ~ SeqList()
 {
 delete[] _data ;
 }
 void test1 ()
 {
 SeqList<double > sl2;
 SeqList<int > sl1() ;
 }

 偏特化（ 局部特化）
 template <typename T1, typename T2>
 class Data
 {
 public :
 Data() ;
 private :
 T1 _d1 ;
 T2 _d2 ;
 } ;
 template <typename T1, typename T2>
 Data<T1 , T2>: : Data()
 {
 cout<<"Data<T1, T2>" <<endl;
 }
 // 局部特化第二个参数
 template <typename T1>
 class Data <T1, int>
 {
 public :
 Data() ;
 private :
 T1 _d1 ;
 int _d2 ;
 } ;
 template <typename T1>
 Data<T1 , int>: : Data()
 {
 cout<<"Data<T1, int>" <<endl;
 }

下面的例子可以看出，偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

 // 局部特化两个参数为指针类型
 template <typename T1, typename T2>
 class Data <T1*, T2*>
 {
 public :
 Data() ;
 private :
 T1 _d1 ;
 T2 _d2 ;
 T1* _d3 ;
 T2* _d4 ;
 } ;
 template <typename T1, typename T2>
 Data<T1 *, T2*>: : Data()
 {
 cout<<"Data<T1*, T2*>" <<endl;
 }
 // 局部特化两个参数为引 用
 template <typename T1, typename T2>
 class Data <T1&, T2&>
 {
 public :
 Data(const T1& d1, const T2& d2) ;
 private :
 const T1 & _d1;
 const T2 & _d2;
 T1* _d3 ;
 T2* _d4 ;
 } ;
 template <typename T1, typename T2>
 Data<T1 &, T2&>: : Data(const T1& d1, const T2& d2)
 : _d1(d1 )
 , _d2(d2 )
 {
 cout<<"Data<T1&, T2&>" <<endl;
 }
 void test2 ()
 {
 Data<double , int> d1;
 Data<int , double> d2;
 Data<int *, int*> d3;
 Data<int&, int&> d4(, ) ;
 }

模板的全特化和偏特化都是在已定义的模板基础之上，不能单独存在。

关于特化的总结：

特化的分类

针对特化的对象不同，分为两类：函数模板的特化和类模板的特化

函数模板的特化：当函数模板需要对某些类型进行特化处理，称为函数模板的特化。
类模板的特化：当类模板内需要对某些类型进行特别处理时，使用类模板的特化。

特化整体上分为全特化和偏特化
全特化就是模板中模板参数全被指定为确定的类型。全特化也就是定义了一个全新的类型，全特化的类中的函数可以与模板类不一样。

偏特化就是模板中的模板参数没有被全部确定，需要编译器在编译时进行确定。

全特化的标志就是产生出完全确定的东西，而不是还需要在编译期间去搜寻适合的特化实现，貌似在我的这种理解下，全特化的东西不论是类还是函数都有这样的特点，

模板函数只能全特化，没有偏特化（重载）。
模板类是可以全特化和偏特化的。

很多时候，我们既需要一个模板能应对各种情形，又需要它对于某个特定的类型（比如bool）有着特别的处理，这种情形下特化就是非常必要的。

模板总结

【优点】
模板复用了代码，节省资源，更快的迭代开发， C++的标准模板库(STL) 因此而产生。
增强了代码的灵活性。

【缺点】
模板让代码变得凌乱复杂，不易维护，编译代码时间变长。
出现模板编译错误时，错误信息非常凌乱，不易定位错误。