Item 25 不应抛出异常的swap

通用的swap可以在stl里找到：

 

namespace std { template<typename T> // 1. std::swap的实现 void swap(T& a, T& b) { T temp(a); a = b; // 2. 只要T支持拷贝 b = temp; } }

 

有很多类使用pimpl来分离实现与接口，对它们的swap要慎重。

 

class WidgetImpl { // 真正的数据与函数实现放在这个类里 public: ... private: int a, b, c; // 会有很多数据，都拷贝则代价很大 std::vector<double> v; ... }; class Widget { // 抽象出来的接口，使用pimpl引用具体实现 public: Widget(const Widget& rhs); Widget& operator=(const Widget& rhs) // to copy a Widget, copy its { // WidgetImpl object. For ... // details on implementing *pImpl = *(rhs.pImpl); // operator= in general, ... // see Items 10, 11, and 12. } ... private: WidgetImpl *pImpl; };

 

其实，swap只要交换二者的指针即可，不用拷贝里面的数据：

 

void Widget::swap(Widget& other) { // 不要在该成员函数里抛出异常！ using std::swap; swap(pImpl, other.pImpl); } namespace std { // 这样定义方式叫做：total template specialization template<> void swap<Widget>(Widget& a, Widget& b) { a.swap(b); } }

 

STL里的容器都是这样实现swap的。

现在假设Widget和WidgetImpl都是模板类，即：

 

template<typename T> class Widget { ... }; template<typename T> class WidgetImpl { ... };

 

那么，如何实现swap呢？下面这样的思路可以吗：

 

namespace std { template<typename T> void swap<Widget<T> >(Widget<T>& a, Widget<T>& b) // 不可以。编译错 { a.swap(b); } }

 

实际上，对模板函数的定义进行“partial specialization”在C++中是无效的。如果编译通过，说明编译器有问题。
不过，对模板类，可以进行“partial specialization”。

那么，重载swap可以解决问题吗：

 

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

 

但是，std这个名字空间，是不适合用上面的方法解决问题的。这属于对std空间增加了新的模板类。
而std空间的内容，只有C++委员会才有权决定。
可能上面的代码在一些编译器上可以正常运行，比如VC，但实际上属于“未定义行为”！

需要稍稍改一下：

 

namespace WidgetStuff { ... // templatized WidgetImpl, etc. template<typename T> // as before, including the swap class Widget { ... }; // member function ... template<typename T> void swap(Widget<T>& a, Widget<T>& b) { a.swap(b); } }

 

把swap移到新的名字空间了。那么，像下面的代码：

 

using WidgetStuff::Widget; Widget<int> w; Widget<int> w2; swap(w, w2);

 

C++将应用argument-dependent lookup (Koenig lookup)规则，进行查找，最后找到以Widget作为参数的swap函数。

从客户的角度看下面的代码：

 

template<typename T> void doSomething(T& obj1, T& obj2) { ... swap(obj1, obj2); ... }

 

哪一个swap会被调用到呢？有可能是std里的通用版本；有可能是std里完全特化的版本；有可能是在某个名字空间里的重载版本。
如果你想让它调用重载版本，当重载版本不存在，就调用std通用版本，那么可以像下面这样写：

 

template<typename T> void doSomething(T& obj1, T& obj2) { using std::swap; // 它会在std通用版本和重载版本里 swap(obj1, obj2); // 挑选最合适的函数 ... }

 

C++查找swap的规则是：先在全局名字空间中找，然后在T的名字空间中找。
在std中，C++优先使用特化的版本，如果该版本存在的话。

有些程序员喜欢这样写：

std::swap(obj1, obj2);

这样就限制了swap的查找。
为了帮助这样的代码也能提高效率，你要在你的类里，定义特化的版本。

基于对“异常安全”的考虑，swap成员函数不应该抛出异常。只有这样，swap才能做到异常安全。
swap的行为基于copy ctor和拷贝赋值。这两个函数可以抛出异常。
自定义swap是为了更高的效率，应该只处理内建类型，所以不应该抛出异常。