这个例子c++类的模板特化与成员函数的特化//都是处理指针类型的;之间的区别没有看出来呀Ecab

[mirroatl270]

#include<iostream>
#include<cstring>
#include<typeinfo>
using namespace std;
template<class T>class D
{
public:
  D(T x,T y):m_x(x),m_y(y){}
  int compare(void)
  {
    cout<<"Type of m_x is "<<typeid(m_x).name()<<endl;
    cout<<"Type of m_y is "<<typeid(m_y).name()<<endl;
    if(m_x<m_y)
return -1;
    if(m_x>m_y)
return 1;
    return 0;
  }
private:
  T m_x;
  T m_y;
};
//类的模板特化
/*template<>class D<char*>
{
public:
  D(char*x,char*y):m_x(x),m_y(y){}
  int compare(void)
  {
    cout<<"***Type of m_x is***"<<typeid(m_x).name()<<endl;
    cout<<"****Type of m_y is***"<<typeid(m_y).name()<<endl;
    if(strcmp(m_x,m_y)>0)
return 1;
    if(strcmp(m_x,m_y)<0)
return -1;
    return 0;
  }
private:
  char* m_x;
  char* m_y;
};*/
//成员函数的特化
template<>
int D<char*>::compare(void)
{
    cout<<"***Type of m_x is***"<<typeid(m_x).name()<<endl;
    cout<<"****Type of m_y is***"<<typeid(m_y).name()<<endl;
    if(strcmp(m_x,m_y)>0)
return 1;
    if(strcmp(m_x,m_y)<0)
return -1;
    return 0;
}
int main(int argc,char*argv[])
{
  D<int>d1(10,20);
  cout<<d1.compare()<<endl;
  
  D<double>d2(0.1,0.2);
  cout<<d2.compare()<<endl;
  
  D<string>d3("good","better");
  cout<<d3.compare()<<endl;


  char sz1[]="courage";
  char sz2[]="excellent";
  D<char*>d4(sz1,sz2);//比较的是两个字符指针
  cout<<d4.compare()<<endl;
  return 0;
}

[derekrose]

可是一个是类，一个是函数啊

[珍惜生命远离CPP]

特化类的时候 可以增加删除类成员、函数

[wocow3]

类模板特化可以调整成员，可以有完全不同的定制 成员特化只是特化某个成员，其他成员还是来自基本模版

[ri_aje]

再复杂点儿的就能看出区别了。比如让指针版的 compare 接受函数对象用于比较字符串，而不是把 strcmp 写死在实现里，这时要求特化的 compare 与泛化的接口不一样，函数模板特化就不管用了。

[tofu_]

代码还少了点，多加点更容易看出区别来。

#include<iostream>
#include<cstring>
#include<typeinfo>
using namespace std;

template<class T>
class D
{
public:
	D(T x, T y) : m_x(x), m_y(y)
	{
	}

	int compare(void)
	{
		cout << "template D compare" << endl;
		return 0;
	}

	void display() { cout << "template D display" << endl; }
private:
	T m_x;
	T m_y;
};

//成员函数的特化
template<>
int D<char*>::compare(void)
{
	cout << "D<char*> compare" << endl;
	return 0;
}

//类的模板全特化
template<>
class D<wchar_t*>
{
public:
	D(wchar_t*x, wchar_t*y) : m_x(x), m_y(y), m_dont_use_me(0)
	{
	}

	int compare(void)
	{
		cout << "D<wchar_t*> compare" << endl;
		return 0;
	}
private:
	wchar_t* m_x;
	wchar_t* m_y;
 	int m_dont_use_me;  // 可以增加哦
};

int main(int argc, char*argv[])
{
	D<int> d1(10, 20);
	d1.compare();	// 毫无疑问输出"template D compare"
	d1.display();	// ok

	char sz1[] = "courage";
	char sz2[] = "excellent";
	D<char*> d2(sz1, sz2);
	d2.compare();	// 当然是"D<char*> compare"
	d2.display();	// also ok

	wchar_t wsz1[3] = {0};
	wchar_t wsz2[3] = {0};
	D<wchar_t*> d3(wsz1, wsz2);
	d3.compare();
//	d3.display();	// error，没有定义

	return 0;
}

成员函数特化只是说，如果T为指定的某个类型，编译器你就要负责调用这个特殊版本的成员函数（d2.compare()说明了这一点）。除了特化的成员函数之外，其他函数依然是原始模板中的定义（d2.diaplay()说明了这一点）。而类模板全特化之后，实际上跟原来的模板完全没有任何关系了。这时候你可以增删成员、函数等等（见上面的代码）。 当然，一般来说，客户希望特化的类模板能跟原来的模板拥有同样的对外接口，所以，若一定要说一个D<wchar_t*>和通用的D<T>还有什么联系的话，就是：尽量让D<wchar_t*>提供与D<T>一样的对外接口。因为用户编写泛型代码的时候，大多数时候肯定是针对D<T>编写，并且希望D<wchar_t*>一样适用。

[mirroatl251]

请问网上说的特化与遍特化就是指的成员函数特化与类模板全特化吗???

引用 5 楼 tofu_ 的回复:

代码还少了点，多加点更容易看出区别来。 C/C++ code ? 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374 #include<io……

[mirro187_]

请问网上说的特化与遍特化就是指的成员函数特化与类模板全特化吗???

引用 4 楼 ri_aje 的回复:

再复杂点儿的就能看出区别了。比如让指针版的 compare 接受函数对象用于比较字符串，而不是把 strcmp 写死在实现里，这时要求特化的 compare 与泛化的接口不一样，函数模板特化就不管用了。

[mirro187_]

请问网上说的特化与遍特化就是指的成员函数特化与类模板全特化吗???

引用 3 楼 wocow3 的回复:

类模板特化可以调整成员，可以有完全不同的定制 成员特化只是特化某个成员，其他成员还是来自基本模版

[tofu_]

引用 8 楼 mirro187_ 的回复:

请问网上说的特化与遍特化就是指的成员函数特化与类模板全特化吗??? 引用 3 楼 wocow3 的回复:类模板特化可以调整成员，可以有完全不同的定制 成员特化只是特化某个成员，其他成员还是来自基本模版

上次回你的帖子的时候不小心按到了某键,然后刷新了...放弃之... 特化分为全特化和偏特化，模板分为函数模板和类模板。这是两组不同的概念，几乎可以看成是正交关系的。 类模板可以全特化和偏特化，函数模板可以全特化，不能偏特化。函数可以通过重载达到与偏特化同样的效果。

template <typename T1, typename T2>
struct some_type_1 {};	// 主模板

template <>
struct some_type_1<int, int> {};	// 全特化

template <typename T>
struct some_type_1<T, int> {};	// 偏特化

template <typename T1, typename T2>
void do_something_1(const T1&, const T2&) {}	// 主模板

template <>
void do_something_1<int, int>(const int&, const int&) {}	// 全特化

template <typename T>
void do_something_1<T, int>(const T&, const int&) {}	// 错误

template <typename T>
struct some_type_2 {};	// 主模板

template <typename T>
struct some_type_2<T*> {};	// 这个也是偏特化

template <typename T>
void do_something_2(T) {};	// 主模板

template <typename T>
void do_something_2(T*) {};	// 看起来好像是个偏特化，其实是个重载的主模板

[MichaelBomb]

单这个例子来看，成员函数特化就够用了。

[beyondcj]

这题目kang!

[mirro187_]

大哥最后问一嘴 函数模板为什么不能偏特化呀??? 语法为啥这么规定！

引用 9 楼 tofu_ 的回复:

引用 8 楼 mirro187_ 的回复:请问网上说的特化与遍特化就是指的成员函数特化与类模板全特化吗??? 引用 3 楼 wocow3 的回复:类模板特化可以调整成员，可以有完全不同的定制 成员特化只是特化某个成员，其他成员还是来自基本模版 上次回你的帖子的时候不小心按到了某键,然后刷新了...放弃之... 特化分为全特化和偏特化，模板分为函数模板和类模板。这是……

[FancyMouse]

引用 12 楼 mirro187_ 的回复:

大哥最后问一嘴 函数模板为什么不能偏特化呀??? 语法为啥这么规定！ 引用 9 楼 tofu_ 的回复:引用 8 楼 mirro187_ 的回复:请问网上说的特化与遍特化就是指的成员函数特化与类模板全特化吗??? 引用 3 楼 wocow3 的回复:类模板特化可以调整成员，可以有完全不同的定制 成员特化只是特化某个成员，其他成员还是来自基本模版 上次回你的帖子的……

因为已经有overload了。允许function的partial specialization会导致重载解析上的混淆。