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(0)
, _capacity(10)
, _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 = 10> //带缺省模板参数
class SeqList
{
public :
SeqList() ;
private :
T _array [MAX_SIZE] ;
int _size ;
} ;
template <typename T, size_t MAX_SIZE>
SeqList <T, MAX_SIZE>: : SeqList()
: _size(0)
{}
void Test()
{
SeqList<int> s1;
SeqList<int , 20> 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-3;
    }
};
// 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-6;
    }
};
int main(void)
{
    Compare<int> comp1;
    std::cout <<comp1.IsEqual(3, 4) <<std::endl;
    std::cout <<comp1.IsEqual(3, 3) <<std::endl;

    Compare<float> comp2;
    std::cout <<comp2.IsEqual(3.14, 4.14) <<std::endl;
    std::cout <<comp2.IsEqual(3, 3) <<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 0;
}

全特化

还是以顺序表为例说明

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

偏特化（ 局部特化）  2 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(1, 2) ;
}

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

关于特化的总结：

特化的分类

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

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

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

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

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

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

1. 模板函数只能全特化，没有偏特化（重载）。

2. 模板类是可以全特化和偏特化的。

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

模板总结

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

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