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 specializationtemplate<>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 swapclass 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是为了更高的效率，应该只处理内建类型，所以不应该抛出异常。