1、内容引出
swap()属于STL的一部分(算法)，而后成为异常安全性编程的脊柱，以及用来处理自我赋值的可能性的一个常见的机制。它是如此的有用，适当的实现就显得十分重要。然而在它的实现的复杂度也比较高。这个条款就在讲swap(）函数的实现问题。
2、 widget 和widgetImpl 都是class时，如何写出高效的swap()
STL 缺省情况下，由STL提供的swap算法完成，如下：
namespace std {
template<typename T>
void swap(T&a, T&b) {
T temp(a);
a = b;
b = temp;
}
}
只要类型T支持copying函数(copy构造、copy赋值符号函数)，就可以调用STL的缺省的swap。
然而，标准库版本的swap却存在一个问题，它的实现进行了3次复制，对于某些实现来说，它导致的效率太低了。这些情况主要是指“以指针指向一个对象，内含真正数据”那种类型。这种设计的常见表现形式是所谓的"pimpl"手法。以这种手法实现widget 代码如下：
class WidgetImpl {
private:
int i;
};
class Widgt {
Widgt(const Widgt&rhs);
Widgt&operator = (const Widgt&rhs) {
*imp = *rhs.imp;
}
private:
WidgetImpl* imp;
};
在这种情况下，实际上我们只交换两个指针的指向便可，没有必要交换所指物。但是怎么才能告诉标准库的swap呢？
答案：在std空间内全特化一个swap函数，然后在widget类内写一个成员函数swap，调用该全特化的swap函数。具体代码如下：
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);
}
}
这种做法的好处：
- 提高了swap函数的效率
- 与STL容器达成了一致性。(STL容器类也提供public swap函数，也全特化了对象的std::swap)
3、如果widget 和widgetImpl 都是类模板，而非类的话，怎么实现？
(1)想法一：偏特化（行不通的想法）
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);
}
}
这种实现是不能通过编译的。widget内放一个swap成员函数时没问题的，但是我们无法偏特化std::swap()。
(2)想法二：我们打算偏特化一个function 模板时，惯常的做法是为其添加一个重载版本。（行不通的想法）
namespace std {
template<typename T>
void swap(Widget<T>&a, Widget<T>&b) {
a.swap(b);
}
}
但是c++不允许重载std中的模板函数,因为这其实是试图扩充std。C++允许在std中全特化某个模板，但是不允许添加新的模板。
(3)想法三：在一个命名空间中定义一个swap 和 Widget WidgetImpl 等等模板， 在这个空间中的swap调用类中的成员函数。但与此同时建议提供一个std的特化Swap版本。
为了简化起见，假设Widget的所有相关机能被置于命名空间WidgetStuff，于是：
namespace WidgetStuff {
... //模板化的WidgetImpl等等
template<typename T> //和前面一样，内含swap成员函数
class Widget { ... };
...
template<typename T> //non-member swap函数
void swap(Widget<T>& a, //这里并不属于std命名空间
Widget<T>& b)
{
a.swap(b);
}
}
此时调用swap，C++的名称查找法则（name lookup rules；更具体的说是所谓argument-dependent lookup或Kobeig lookup法则）将会找到WidgetStuff内的Widget专属版本，这正是我们所希望的。
注意：
- 虽然上面的做法对于class和classtemplate都行得通，但我们还是应该为class特化std::swap。所以，如果我们想让“class专属版”的swap在尽可能多的语境下被调用，我们就应该同时在该class所在命名空间内写一个non-member版本以及一个std::swap特化版本。
- 没有上述命名空间，代码也行得通，相当于将他们放在了global中，不推荐这样做。
4、用户角度
从用户角度考虑，假设正在写一个function template，其内需要置换两个对象值。
template<typename T>
void doSomething(T& obj1, T& obj2)
{
...
swap(obj1, obj2);
...
}
(1)此时，调用了swap，但是调用的是哪一个一般化版本？
- std既有的一般化版本？
- 某个可能存在的特化版本？
- 存在的T专属版本而且可能存在与某个命名空间内（非std内）
我们希望的是调用T专属版本，并在该版本不存在的情况下，再去调用std内的一般化版本，那么正确的写法如下：
template<typename T>
void doSomething(T& obj1, T& obj2)
{
usint std::swap; //令std::swap在此函数内可用
...
swap(obj1, obj2); //为T型对象调用最佳swap版本
...
}
一旦编译器看到了对swap的调用，它们便查找适当的swap并加以调用。C++的名称查找法则会确保将找到global作用域或者T所在的命名空间内的任何T专属的swap。
(2)C++的名称查找法则的具体做法：
- 如果T是Widget并位于命名空间WidgetStuff内，编译器就会使用“实参取决的查找规则”（argument-dependentlookup）找出WidgetStuff内的swap。
- 如果没有T专属的swap存在，编译器就会使用std内的swap——由using std::swap这条语句，使得这个选择被曝光。
(3)注意
如果已经针对T将std::swap进行了特化，这个特化版本也直接会被优先使用。因此，令适当的swap被调用是比较容易的。但需要小心的是：不要添加额外的修饰符，这样会影响C++挑选适当的函数:
std::swap(obj1, obj2); //错误的swap调用方式
上面这个举动，会迫使编译器只认std内的swap，因而不再可能调用一个定义于其他地方的适当T专属版本。
5、总结
关于：
- default swap
- member swap
- non-member swap
- std::swap 特化版本
- swap的调用
做一个总结：
首先，如果swap的缺省实现对我们的class或class template提供可接受的效率，那么我们并不需要做其他的事情。
其次，如果swap的缺省版本效率不足（通常就是因为class或者class template使用了某种pimpl手法），则：
- 提供一个public swap成员函数，让它高效地置换对应类型的两个对象值。这个函数绝不能抛出异常！
- 在我们的class或template所在的命名空间内提供一个non-member swap，并令它调用上述swap成员函数。
- 如果我们正在编写一个class（而非classtemplate），为我们的class特化std::swap。并令它调用我们的swap成员函数。
最后，如果我们调用swap，请确定包含一个using声明式，以便让std::swap在我们的函数内部可以曝光可见，然后不加任何namespace修饰符，直接去调用swap。
6、最后，还有一点关于成员版本的swap：绝对不可以抛出异常！
(1)原因
swap的一个最好的应用就是为了帮助class（和class template）提供强烈的异常安全性（exception-safety）保障。
(2)适用
当然，这一约束只施行于成员版！不可实施于非成员版，因为swap缺省版本是以copy构造函数和copy assignment操作符为基础的，在一般情况下是允许抛出异常的。
因此，当我们写一个自定义版本的swap时，往往需要提供以下两点：
- 高效置换对象值的办法
- 不抛出异常
一般而言，上面这两个特性是连在一起的，因为高效率的swap几乎总是基于对内置类型的操作（例如pimpl首发的底层指针），而内置类型上的操作绝不会抛出异常。