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

这是我在阅读Effective c++中认为比较重要的部分，下面给出了我对这一节的理解，并写出对应的比较容易理解的代码。

标准库std命名空间中 的swap定义如下：

namespace std {
	template<typename T>
	void swap(T&a, T&b) {
		T temp(a);
		a = b;
		b = temp;
	}
}

只要T类型支持拷贝构造和拷贝赋值就可以使用swap，然而对pimpl手法的类使用swap，却很缺乏效率。 pimpl手法是以指针指向一个对象，那个对象内含真正数据。

一个典型的pimpl类如下:

class WidgetImpl {
private:
	int i;
};
class Widgt {
	Widgt(const Widgt&rhs);
	Widgt&operator = (const Widgt&rhs) {
		*imp = *rhs.imp;
	}
private:
	WidgetImpl* imp;

};

真正需要交换的是两个对象的指针，而不是两个对象。

一个思路是在widget内声明一个名为swap的public成员函数做真正的置换工作，然后将std:;swap特化，令它调用该成员函数。

VS2015不能将swap全特化 DEVC++可以

代码如下:

class WidgetImpl {
public:
	int i;
};
class Widgt {
public:
	Widgt() = default;
	Widgt(const Widgt&rhs);
	Widgt&operator = (const Widgt&rhs) {
		*imp = *rhs.imp;
	}
	void swap(Widgt& other) {
		using std::swap;
		swap(imp, other.imp);
	}
public:
	WidgetImpl* imp;

};

namespace std {
	template<>
	void swap<Widgt>(Widgt&a, Widgt&b) {
		a.swap(b);
	}

}

当Widget和WidgetImpl都是类模板时，以下是偏特化版本，但是c++不支持函数模板的偏特化版本。如下：

template<typename T>
class WidgetImpl{};

template<typename T>
class Widget{};

namespace std {
	template<typename T>
	void swap<Widget<T>>(Widget<T>&a, Widget<T>&b) {
		a.swap(b);
	}
}

然后尝试重载版本，如下：

namespace std {
	template<typename T>
	void swap(Widget<T>&a, Widget<T>&b) {
		a.swap(b);
	}
}

但是c++不允许重载std中的函数,解决方法是在一个命名空间中定义一个swap 和 Widget WidgetImpl 等等模板， 在这个空间中的swap调用类中的成员函数。但与此同时建议提供一个std的特化Swap版本。

一旦编译器看到对swap的调用，它们便会查找适当的swap并调用之，C++的名称查找法则将确保找到global作用域或T所在的命名空间中的任何T专属的swap，优先使用T所在命名空间中的swap，然后使用std中的swap， 别忘使用using std::swap使之在此命名空间可见，如果已经将std::swap特化，那么特化版本会被选中。

这里举一个小例子:

template<typename T>
class A {
public:
	T i=10;
};
namespace LKQ1 {
	template<typename T>
	void gg(A<T> a) {
		cout << a.i << endl;
	}
}

template<typename T>
void dosomething(T&obj1) {
	using LKQ2::gg;
	using LKQ1::gg;
	gg(obj1);
}

namespace  LKQ2{
	template<typename T>
	void gg(T a) {
		cout << a.i << endl;
		cout << "this is a second part" << endl;
	}
}

namespace LKQ2 {
	template< >
	void gg<A<int>>(A<int>a) {
		cout << a.i << endl;
		cout << "this is a special second part version of LKQ2" << endl;

	 }
}

int main() {
	A<int> a;
	dosomething(a);
}

 

其中有类模板A，匹配类模板A参数的函数模板LKQ::gg,以及不完全匹配类模板A参数的函数模板LKQ2::gg和对应匹配模板A参数A<int>的一个特化版本。

在main中实例化一个A<int> 的对象，调用dosomething, gg会根据模板参数推导，推导出模板参数T的类型为A<int>，编译器首先找到是命名空间LKQ1中的gg， 然后是命名空间LKQ2中gg的特化版本，最后才是LKQ2中gg的泛化版本。

请记住

当std::swap对你的类型效率不高时,提供一个swap成员函数,并确定这个函数不抛出异常。

假设你提供一个member swap,也该提供一个non-member swap用来调用前者.对于classes(而非template),也请特化std::swap。
调用swap时应针对std::swap使用using声明式,然后调用swap而且不带不论什么"命名空间资格修饰“。
为"用户定义类型"进行std templates全特化是好的,但千万不要尝试在std内增加某些std而言全新的东西。