1、类模板
1、类模板定义
定义一个栈的类模板,它可以用来容纳不同的数据类型,说明如下:
template <class T>
class stack {
private:
list* top;
public:
stack();
stack(const stack&);
~stack();
void push(T&);
T& pop();
//…
};
上述定义中,template告诉编译器这是一个模板,尖括号中的<class T >
指明模板的参数,可以有一个或多个,具体实现时由用户指定,其中template <class T >
中的关键字class可以用关键字typename来代替。
类模板的使用除了要在声明时指明模板参数外,其余均与普通的类相同,例如:
stack<int> int_stack;
stack<char> ch_stack;
stack<string> str_stack;
int_stack.push(10);
ch_stack.push(‘z’);
str_stack.push(“c++”);
2、类模板特化
有时为了需要,针对特定的类型,需要对模板进行特化,也就是特殊处理。例如,stack类模板针对bool类型,因为实际上bool类型只需要一个二进制位,就可以对其进行存储,使用一个字或者一个字节都是浪费存储空间的。
template <class T>
class stack {};
//对模板进行特化:
template < >
class stack<bool> { //…// };
上述定义中template < >
告诉编译器这是一个特化的模板。
类模板特化的几种类型, 一是特化为绝对类型; 二是特化为引用,指针类型;三是特化为另外一个类模板。!!!!!
以下述代码为例:
// general version
template<class T>
class Compare
{
public:
static bool IsEqual(const T& lh, const T& rh)
{
return lh == rh;
}
};
这是一个用于比较的类模板,里面可以有多种用于比较的函数, 以IsEqual为例。
1、特化为绝对类型
也就是说直接为某个特定类型做特化,这是我们最常见的一种特化方式, 如特化为float, double等。
// specialize for float
template<>
class Compare<float>
{
public:
static bool IsEqual(const float& lh, const float& rh)
{
return abs(lh - rh) < 10e-3;
}
};
2、特化为引用,指针类型
除了T*
, 我们也可以将T特化为 const T*, T&, const T&
等,以下还是以T*为例:
// specialize for T*
template<class T>
class Compare<T*>
{
public:
static bool IsEqual(const T* lh, const T* rh)
{
return Compare<T>::IsEqual(*lh, *rh);
}
};
这种特化其实是就不是一种绝对的特化, 它只是对类型做了某些限定,但仍然保留了其一定的模板性,这种特化给我们提供了极大的方便, 如这里, 我们就不需要对int*, float*, double*等等类型分别做特化了。
3、特化为另外一个类模板
这其实是第二种方式的扩展,其实也是对类型做了某种限定,而不是绝对化为某个具体类型,如下:
// specialize for vector<T>
template<class T>
class Compare<vector<T> >
{
public:
static bool IsEqual(const vector<T>& lh, const vector<T>& rh)
{
if(lh.size() != rh.size()) return false;
else
{
for(int i = 0; i < lh.size(); ++i)
{
if(lh[i] != rh[i]) return false;
}
}
return true;
}
};
这就把IsEqual的参数限定为一种vector类型,但具体是vector<int>
还是vector<float>
, 我们可以不关心。
3、类模板的偏特化
模板的偏特化是指需要根据模板的某些但不是全部的参数进行特化。
例如c++标准库中的类vector的定义
template <class T, class Allocator>
class vector { // … // };
//对模板的T参数偏特化
template <class Allocator>
class vector<bool, Allocator> { //…//};
这个偏特化的例子中,一个参数被绑定到bool类型,而另一个参数仍未绑定需要由用户指定。
2、函数模板
1、函数模板定义
假设现在要定义一个max函数来返回同一类型(这种类型是允许比较的)两个值的最大者.
template<class T>
T mymax(const T& t1,const T& t2)
{ return t1 < t2 ? t2 : t1; }
template <class T>
的意义与类模板定义中相同。
模板函数的使用与普通非模板函数使用相同,因为模板函数的参数可以从其传入参数中解析出来。例如:
int highest = mymax(5,10);
char c = mymax(‘a’, ’z’);
mymax(5,10)
解析出模板函数参数为int, mymax(‘a’, ’z’)
解析出模板函数的参数为char。
2、函数模板的特化
看下面的例子
main()
{
int highest = mymax(5,10);
char c = mymax(‘a’, ’z’);
const char* p1 = “hello”;
const char* p2 = “world”;
const char* p = mymax(p1,p2);
}
前面两个mymax都能返回正确的结果。而第三个却不能,因为此时mymax直接比较两个指针p1 和 p2 而不是其指向的内容。
针对这种情况,当mymax函数的参数类型为const char* 时,需要特化。
template <class T>
T mymax(const T t1, const T t2)
{
return t1 < t2 ? t2 : t1;
}
//对函数模板进行特化:
template <>
const char* mymax(const char* t1,const char* t2)
{
return (strcmp(t1,t2)<0) ? t2 : t1;//比较方法要做特定修改
}
现在mymax(p1,p2)能够返回正确的结果了。
3、函数模板的偏特化
严格的来说,函数模板并不支持偏特化!!!,但由于可以对函数进行重载,所以可以达到类似于类模板偏特化的效果。