除了定义拷贝控制成员，管理资源的类通常还定义一个名为 swap 的函数。对于那些与重排元素顺序的算法一起使用的类，定义 swap 是非常重要的。这类算法在需要交换两个元素时会调用 swap。
如果一个类定义了自己的 swap，那么算法将使用类自定义版本。否则，算法将使用标准库定义的 swap。
编写我们自己的 swap 函数
class HasPtr
{
public:
HasPtr(const std::string &s = std::string()) : ps(new std::string(s)), i(0),
use_count(new std::size_t(1))
{}
HasPtr(const HasPtr &p) : ps(p.ps), i(p.i), use_count(p.use_count)
{
++*use_count;
}
~HasPtr();
HasPtr& operator=(const HasPtr&p);
friend void swap(HasPtr& lh, HasPtr& rh);
private:
std::string *ps;
int i;
std::size_t *use_count;
};
inline void swap(HasPtr &lh, HasPtr &rh)
{
using std::swap;
swap(lh.ps, rh.ps);
swap(lh.i, rh.i);
}
与拷贝控制成员不同，swap 并不是必要的。但是，对于分配了资源的类，定义 swap 可能是一种很重要的优化手段。
swap 函数应该调用 swap，而不是 std::swap
此代码中有一个很重要的微妙之处：虽然这一点在这个特殊的例子中并不重要，但在一般情况下它非常重要——swap 函数中调用的 swap 不是 std::swap。在本例中，数据成员是内置类型的，而内置类型是没有特定版本的 swap 的，所以在本例中，对 swap 的调用会调用标准库 std::swap。
但是，如果一个类的成员有自己类型特定的 swap 函数，调用 std::swap 就是错误的了。例如，假定我们有个名为 Foo 的类，它有一个类型为 HasPtr 的成员 h。如果我们未定义 Foo 版本的 swap，那么就会使用标准库版本的 swap。如我们所见，标准库 swap 对 HasPtr 管理的 string 进行了不必要的拷贝。
我们可以为 Foo 编写一个 swap 函数，来避免这些拷贝。但是，如果这样编写 Foo 版本的 swap：
inline void swap(Foo& lh, Foo& rh) {
// 错误：这个函数使用了标准库版本的 swap，而不是 HasPtr 版本
std::swap(lh.h, rh.h);
// 交换其他成员
}
使用此版本与简单使用默认版本的 swap 并没有任何性能差异。虽然我们显示地调用了标准库版本的 swap。但是，我们不希望 std 中的版本，我们希望调用为 HasPtr 对象定义的版本。
因此，正确的 swap 函数如下所示：
inline void swap(Foo& lh, Foo& rh) {
using std::swap;
swap(lh.h, rh.h);
// 交换其他成员
}
每个 swap 调用应该都是未加限定的。即，每个调用都应该是 swap，而不是 std::swap。如果存在类型特定的 swap 版本，其匹配程度会由于 std 中定义的版本。
在赋值运算符中使用 swap
定义 swap 的类通常用 swap 来定义它们的赋值运算符。这些运算符使用了一种名为 拷贝并交换 （copy and swap）的技术。这种技术将左侧运算对象与右侧运算对象的一个副本进行交换：
HasPtr &HasPtr::operator=(HasPtr p)
{
swap(*this, p);
return *this;
}
在这个版本的赋值运算符中，参数不再是引用，而是传值。因此，p 是右值运算符对象的一个副本。参数传递时拷贝 HasPtr 的操作会分配该对象的 string 的一个新副本。
在赋值运算符的函数体中，我们调用 swap 来交换 p 和 *this 中的数据成员。这个调用将左侧运算对象中原来保存的指针存入 p 中，并将 p 中原来的指针存入 *this 中。因此，在 swap 调用之后，*this 中的指针成员将指向新分配的 string —— 右侧运算对象中 string 的一个副本。
当赋值运算符结束时，p 被销毁，HasPtr 的析构函数将执行。此析构函数 delete p 现在指向的内存，即，释放掉左侧运算对象中原来的内存。
这个技术自动处理了自赋值的情况并且是异常安全的。它通过在改变左侧运算对象之前拷贝右侧运算对象保证了自赋值的正确，这与我们在原来的赋值运算符中使用的方法是一致的。它保证异常安全的方法也与原来的赋值运算符实现一样。代码中唯一可能抛出异常的是拷贝构造函数中的 new 表达式。如果真的发生了异常，它也会在我们改变左侧运算对象之前发生。
