std::swap()
std::swap()是一个很简单的函数：交换两个参数的值，仅此而已。但是这个看似平淡无奇的函数，背后的故事却不简单。不知道你考虑过下面问题没有：
- 我们通常要求这个函数不能抛出异常，为什么？
- 如何才能让
std::swap函数能高效地作用于你自己定义的类？
要回答这两个问题，就要从std::swap的实现说起。
std::swap()的实现
libc++中，swap()定义在文件“type_traits”中：
// file: type_traits
template
typename enable_if<
is_move_constructible::value &&
is_move_assignable::value
>::type
swap(T& x, T& y) noexcept(
is_nothrow_move_constructible::value &&
is_nothrow_move_assignable::value) {
T t(std::move(x));
x = std::move(y);
y = std::move(t);
}
从定义可以看出：
一个“swappable”的类型必须满足“move constructible”和“move assignable”两个前提条件，这是C++11的新要求。
如果类型
T的“move constructor”和“move assignment operator”不抛出异常，则swap也不能抛出异常。
虽然标准并没有强制规定swap()不能抛出异常，但是实际使用中，我们都要确保swap()不抛出异常，这是为什么呢？要回答这个问题，就要从C++异常安全保证说起。
异常安全保证
维基百科对异常安全保证（Exception Safety Guarantees）的解释是“类的设计者和使用者在使用任何一门程序设计语言，特别是C++时可以遵守的一系列异常处理准则”。
异常安全保证从弱到强可以分为三个等级：
基本保证（Basic Exception Safety）: 也叫无泄漏保证（No-Leak Guarantee），即发生异常时不会导致资源泄露（比如内存泄露），程序内的任何事物仍然保持在有效状态下，没有对象或数据结构会因此而破坏，所有对象都处于有效的状态，但是处于哪个状态不可预知。
强烈保证（Strong Exception Safety）：如果抛出异常，程序状态不改变。就像数据库中的事务处理一样，要么成功，如果不成功，则程序回到调用之前的状态。
不抛出异常保证（No-Throw Guarantee）：承诺绝不抛出异常。如果有异常发生，会在内部处理，保证不让异常逃逸。
不抛出异常保证还比较好理解，不过另外两个保证可能会让你有点摸不着头脑，下面我就举个例子来说明。假设你要实现一个list数据结构，你打算用一系列相互连接的节点来实现这个list：
template
class list {
private:
template
struct node {
U value;
node* next;
node(U&& val) : value(std::move(val)) {}
};
node* _head;
size_t _length; // length of list
public:
// ...
void insert(T&& val);
inline size_t length() { return _length;}
//...
};
因为查询list的长度是一个常用的操作，所以你将list的长度保存在_length中。同时，list还应该支持从头部插入新元素：
template
void list::insert(T&& val) {
++_length;
node* n = new node(std::forward(val));
n->next = _head;
_head = n;
}
现在设想一下，如果insert函数抛出了异常会发生什么？要弄清楚问题的答案，首先要弄清楚哪行代码会抛出异常。很显然，在insert函数中，最有可能、或者说唯一有可能抛出异常的代码是
node* n = new node(std::forward(val));
假如这行代码抛出异常，因为insert并没有捕捉异常，所以异常会向上传播，达到insert的调用者，进一步假设insert的调用者捕捉到了这个异常，并决定忽略这个错误，就像这样：
void insert_and_print(const list &l) {
try {
l.insert(1);
}
catch(...) {
// log error here
}
std::cout << "There are " << l.length() << " element(s) in list";
}
list l;
insert_and_print(l);
如果l.insert(1)失败，你可能认为上面的代码会输出
There are 0 element(s) in list
错！大错特错！这才是你会看到的：
There are 1 element(s) in list
我们再来看一下insert()的代码：
template
void list::insert(T&& val) {
++_length;
node* n = new node(std::forward(val));
n->next = _head;
_head = n;
}
注意在调用new之前，_length的值已经被改变了，也就是说新元素并没有被插入，但是list的内部状态已经被改变了。
在这里，函数insert_and_print提供了基本异常保证，当异常发生了，程序可以继续执行，不会有资源泄露，但是list内部的状态已经被改变，而且变成了非法的状态，这是很危险的。
通常来说，基本异常安全保证并不是我们追求的目标，因为基本异常安全保证只保证不泄露资源，并不保证程序总是处于合法的状态，所以我们总希望提供强烈安全保证。你可能觉得这很难，其实并非如此，我们把list::insert方法稍做改动：
template
void list::insert(T&& val) {
node* n = new node(std::forward(val));
++_length;
n->next = _head;
_head = n;
}
只需要把++_length放到new之后，insert就摇身一变，变成了一个提供强烈异常安全保证的函数，因为即使分配内存失败，函数异常退出，_length没有变，_head也没有变，整个list的状态没有任何改变，整个程序任然能愉快地运行！
扯了这么多，你可能已经不耐烦了：“这TMD和swap有什么关系？”
std::swap和异常安全保证
如果你有一个管理资源的类，比如智能指针，那么一个不抛出异常的swap()将会非常有用。对于管理资源的类，你通常都需要定义析构函数、拷贝构造函数，拷贝赋值函数、移动构造函数和移动赋值操作。有了swap()，拷贝赋值函数和移动构造函数将会变得很简单，而且提供强烈异常安全保证。
假如你有一个类ResourceManager，你可以这样实现上面
class ResourceManager {
// ....
public:
ResourceManager(const ResourceManager &other);
// 拷贝赋值函数，注意参数是pass-by-value
ResourceManager& operator=(ResourceManager other) {
// 因为是pass-by-value，“other”相当于一个临时变量，
// 函数退出后会被析构掉，避免了资源泄露
swap(*this, other);
return *this;
}
// 移动构造函数
ResourceManager(ResourceManager &&other)
: /* 初始化成员变量 */ {
swap(*this, other);
}
};
这个技巧在C++中是如此常见，以至于已经成为了一种“idiom”，也就是我们常说的“copy-and-swap idom”。Stack Overflow上有一篇很好的关于swap-and-copy idiom的文章，有兴趣的可以去看看。
现在我们知道了为什么一个不抛出异常的swap()很重要，但是还有一个重要的问题：如何才能让swap()能够高效地作用于我们自定义的类？
实现你自己的swap()
前面我们已经看到了std::swap()的源代码，三行简单的代码居然调用了一次拷贝构造函数，两次拷贝赋值函数，很多时候这样的行为都包含着资源的分配和释放，而资源的分配和释放是非常低效率的，这对于为效率而生的C++而言是不可接受的，这就是为什么标准库中的几乎每个类都重载了swap()的原因。如果你有一个管理资源的类，你几乎总是需要重载swap()，那该怎样做呢？很简单，定义两个swap()：一个类成员swap和一个重载的std::swap：
class ResourceManager {
// ...
public:
// 1. 定义类成员函数
void swap(ResourceManager &other) noexcept {
// do swap here
}
};
// 2. 重载swap
inline void swap(ResourceManager &x, ResourceManager &y) noexcept {
using std::swap; // 保证有机会调用std::swap
x.swap(y);
}