c++中的特化问题

C++类模板的三种特化：

（1）特化为绝对类型：即直接为某个特定类型做特化。

下面给出代码实例：

template<typename T>
class Test
{
public:
Test(T t = 0):data(t)
{
cout << "Test object!" << endl;
}
private:
T data;
};

template<class T>
class Compare
{
public:
static bool IsEqual(const T& lh,const T& rh)
{
cout << "Compare<T>!" << endl;
return lh == rh;
}
};

template<>
class Compare<float>
{
public:
static bool IsEqual(const float& lh,const float& rh)
{
cout << "Compare<float>!" << endl;
return abs(lh  - rh) < 10e-3;
}
};

template<>
class Compare<double>
{
public:
static bool IsEqual(const double& lh,const double& rh)
{
cout << "Compare<double>!" << endl;
return abs(lh - rh) < 10e-6;
}
};

int main(int argc,char**argv)
{
Compare<int> a;
a.IsEqual(5,3);

Compare<float> b;
b.IsEqual(5.1f,3.3f);

Compare<double> c;
c.IsEqual(5.1,3.3);

return 0;
}

代码的执行结果如下：



（2）特化为引用，指针类型。

template<class T>
class Compare
{
public:
static bool IsEqual(const T& lh,const T& rh)
{
cout << "Compare<T>!" << endl;
return lh == rh;
}
};

template<>
class Compare<int>
{
public:
static bool IsEqual(const int& lh,const int& rh)
{
cout << "Compare<int>!" << endl;
return lh == rh;
}
};

template<class T>
class Compare<T&>
{
public:
static bool IsEqual(const T& lh,const T& rh)
{
cout << "Compare<T&>!" << endl;
return Compare<T>::IsEqual(lh,rh);
}
};

template<class T>
class Compare<T*>
{
public:
static bool IsEqual(const T* lh,const T* rh)
{
cout << "Compare<T*>!" << endl;
return Compare<T>::IsEqual(*lh,*rh);
}
};

int main(int argc,char**argv)
{
int * p1 = new int(10);
int * p2 = new int(20);
Compare<int*> c;
c.IsEqual(p1,p2);

int a = 10;
int b = 3;
int &a1 = a;
int &b1 = b;
Compare<int&> d;
d.IsEqual(a1,b1);

return 0;
}

除了特化为T*，我们也可以转化为const T*，T&，const T&。

（3）转化为另一个类的模板

template<class T>
class Test
{
public:
Test(T t = T()):data(t)
{
cout << "Test object!" << endl;
}
public:
bool operator==(const T& t)
{
return this->data == t.data;
}
T get_data()const
{
return data;
}
private:
T data;
};

template<class T>
class Compare
{
public:
static bool IsEqual(const T& lh,const T& rh)
{
cout << "Compare<T>!" << endl;
return lh == rh;
}
};

template<class T>
class Compare<vector<T> >
{
public:
static bool IsEqual(const vector<T>& lh,const vector<T>& rh)
{
cout << "Compare<vector<T> >!"<< endl;
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;
}
};

template<class T>
class Compare<Test<T> >
{
public:
static bool IsEqual(const Test<T>& lh,const Test<T>& rh)
{
cout << "Compare<Test<T> >!" << endl;
return lh.get_data() == rh.get_data();
}
};

int main(int argc,char**argv)
{
Test<int> a(10);
Test<int> b(15);

Compare<Test<int> > c;
c.IsEqual(a,b);
return 0;
}
#endif

以上就是C++类模板特化的三种形式。。。。

我们下面来看类模板成员函数的特化：

//类模板成员函数的特化
class Test
{
public:
Test()
{
cout << "Test()!" << endl;
}
};

class Sample2
{
public:
template<class T>
void print()
{
cout << "Sample2 print template!" << endl;
}
};

template<>
void Sample2::print<double>()
{
cout << "Sample2 print char!" << endl;
}

template<>
void Sample2::print<int>()
{
cout << "Sample2 print int!" << endl;
}

template<>
void Sample2::print<char>()
{
cout << "Sample2 print char!" << endl;
}

template<>
void Sample2::print<Test>()
{
cout << "Sample2 print Test!" << endl;
}

int main(int argc,char**argv)
{
Sample2 sam2;
sam2.print<double>();
sam2.print<int>();
sam2.print<char>();
sam2.print<Test>();
return 0;
}

类的成员模板函数的特化：

//类的成员模板函数的特化
class Test
{
public:
Test()
{
cout << "Test()!" << endl;
}
};

template<class T>
class Sample
{
public:
void print()
{
cout << "print template!" << endl;
}
};

template<>
void Sample<int>::print()
{
cout << "print int!" << endl;
}

template<>
void Sample<Test>::print()
{
cout << "print Test!" << endl;
}

int main(int argc,char**argv)
{
Sample<int> a;
a.print();

Sample<double> b;
b.print();

Sample<Test> c;
c.print();
return 0;
}