条款25：考虑写一个不抛出异常的swap函数

一、全特化与偏特化

特化的意义：对于特定类型如果你有更好的方式实现，就应该由你来实现。

全特化：指定模板的每个数据类型

偏特化：只指定模板中某些数据类型

1、类的全特化和偏特化

#include <iostream>

using namespace std;

template<typename TYPE1, typename TYPE2>
class myClass
{
public:
	myClass(TYPE1 i, TYPE2 j):a(i), b(j){cout<<"这是类模板"<<endl;}
	
private:
	TYPE1 a;
	TYPE2 b;
};

template<>
class myClass<int, char>
{
public:
	myClass(int i, char j):a(i), b(j){cout<<"这是上述类的全特化"<<endl;}
private:
	int a;
	char b;
};

template<typename TYPE2>
class myClass<int, TYPE2>
{
public:
	myClass(int i, TYPE2 j):a(i), b(j){cout<<"这是上述类的偏特化"<<endl;}
private:
	int a;
	TYPE2 b;
};

int main()
{
	myClass<double, float> obj1(1.0,2.0);   //调用类模板 
	myClass<int, char> obj2(1,'c');         //调用全特化 
	myClass<int, double> obj3(1, 2.0);      //调用偏特化 
	return 0;
}

2、函数的全特化

#include <iostream>

using namespace std;

template<typename TYPE1, typename TYPE2>
void myFunction(TYPE1 a, TYPE2 b)
{
	cout<<"这是函数模板"<<endl;
}

template<>
void myFunction<int, char>(int a, char b) 
{
	cout<<"这是上述函数模板的全特化"<<endl;
}

//template<typename TYPE2>
//void myFunction<int, TYPE2>(int a, TYPE2 b)
//{
//	cout<<"这是上述函数模板的偏特化"<<endl; 
//}


int main()
{
	myFunction(1.0, 2.0);  //调用函数模板 
	myFunction(1, 'c');    //调用函数全特化 
	myFunction(1, 1.0);    //调用函数模板 
	return 0;
}

注意：函数不可以偏特化，其功能可以通过函数重载实现。

参考：模板的全特化和偏特化

二、swap函数

1、具体的类情况下如何设计swap函数

#include <iostream>

using namespace std;

class myClassImpl
{
public:
	myClassImpl(int i):val(i){}
	int getVal(){return val;}

private:
	int val;
};

//具体类
class myClass
{
public:
	myClass(int i):p(new myClassImpl(i)){}
	~myClass(){delete p;}
	myClass operator=(const myClass rhs)
	{
		*p = *(rhs.p);
	}
	int getVal()
	{
		return p->getVal();
	}
	void swap(myClass& other)
	{
		using std::swap;
		swap(p, other.p);
	}
	
private:
	myClassImpl* p;
};

//全特化std中的swap函数
namespace std
{
	template<>
	void swap<myClass>(myClass& a, myClass& b)
	{
		a.swap(b);
	} 
} 

int main()
{
	myClass a(1);
	myClass b(2);
	cout << a.getVal() << " " << b.getVal() << endl;
	swap(a,b);
	cout << a.getVal() << " " << b.getVal() << endl;
	return 0;
}

2、模板类的情况下如何设计swap函数

</pre><pre name="code" class="cpp">#include <iostream>

using namespace std;

namespace mySpace
{
	
template<typename TYPE>
class myClassImpl
{
public:
	myClassImpl(TYPE i):val(i){}
	TYPE getVal(){return val;}

private:
	TYPE val;
};

//模板类
template<typename TYPE>
class myClass
{
public:
	myClass(TYPE i):p(new myClassImpl<TYPE>(i)){}
	~myClass(){}
	TYPE operator=(const myClass rhs)
	{
		*p = *(rhs.p);
	}
	TYPE getVal()
	{
		return p->getVal();
	}
	void swap(myClass& other)
	{
		using std::swap;
		swap(p, other.p);
	}
private:
	myClassImpl<TYPE>* p;
};

//函数模板不能偏特化，通过重载swap函数实现 
template<typename TYPE>
void swap(myClass<TYPE>& a, myClass<TYPE>& b) 
{
	a.swap(b);
}
}

int main()
{
	mySpace::myClass<int> a(1);
	mySpace::myClass<int> b(2);
	cout << a.getVal() << " " << b.getVal() << endl;
	mySpace::swap(a,b);
	cout << a.getVal() << " " << b.getVal() << endl;
	return 0;
}

参考： http://blog.youkuaiyun.com/thefutureisour/article/details/7965591