# Item 25: 考虑支持不抛异常的 swap
作者：Scott Meyers
译者：fatalerror99 (iTePub's Nirvana)
发布：http://blog.csdn.net/fatalerror99/
swap 是一个有趣的函数。最早作为 STL 的一部分被引入，后来它成为异常安全编程（exception-safe programming）的支柱（参见 Item 29）和压制自赋值可能性的通用机制（参见 Item 11）。因为 swap 太有用了，所以正确地实现它非常重要，但是伴随它的不同寻常的重要性而来的，是一系列不同寻常的复杂性。在本 Item 中，我们就来研究一下这些复杂性究竟是什么样的以及如何对付它们。
交换两个对象的值就是互相把自己的值送给对方。缺省情况下，通过标准的交换算法来实现交换是非常成熟的技术。典型的实现完全符合你的预期：
```
namespace std {
template<typename T> // typical implementation of std::swap;
void swap(T& a, T& b) // swaps a's and b's values
{
T temp(a);
a = b;
b = temp;
}
}
```
只要你的类型支持拷贝（通过拷贝构造函数和拷贝赋值运算符），缺省的 swap 实现就能交换你的类型的对象，而不需要你做任何特别的支持工作
可是，缺省的 swap 实现可能不那么酷。它涉及三个对象的拷贝：从 a 到 temp，从 b 到 a，以及从 temp 到 b。对一些类型来说，这些副本全是不必要的。对于这样的类型，缺省的 swap 就好像让你坐着快车驶入小巷。
这样的类型中最重要的就是那些主要由一个指针组成的类型，那个指针指向包含真正数据的另一种类型。这种设计方法的一种常见的表现形式是 "pimpl idiom"（"pointer to implementation" ——参见 Item 31）。一个使用了这种设计的 Widget 类可能就像这样：
```
class WidgetImpl { // class for Widget data;
public: // details are unimportant
...
private:
int a, b, c; // possibly lots of data —
std::vector<double> v; // expensive to copy!
...
};
class Widget { // class using the pimpl idiom
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; // ptr to object with this
};
```
为了交换这两个 Widget 对象的值，我们实际要做的就是交换它们的 pImpl 指针，但是缺省的交换算法没有办法知道这些。它不仅要拷贝三个 Widgets，而且还有三个 WidgetImpl 对象，效率太低了。一点都不酷。
当交换 Widgets 的是时候，我们应该告诉 std::swap 我们打算做什么，执行交换的方法就是交换它们内部的 pImpl 指针。这种方法的正规说法是：针对 Widget 特化 std::swap（specialize std::swap for Widget）。下面是一个基本的想法，虽然在这种形式下它还不能通过编译：
```
namespace std {
template<> // this is a specialized version
void swap<Widget>(Widget& a, // of std::swap for when T is
Widget& b) // Widget; this won't compile
{
swap(a.pImpl, b.pImpl); // to swap Widgets, just swap
} // their pImpl pointers
}
```
这个函数开头的 "template<>" 表明这是一个针对 std::swap 的完全模板特化（total template specialization）（某些书中称为 "full template specialization" 或 "complete template specialization" ——译者注），函数名后面的 "<Widget>" 表明特化是在 T 为 Widget 类型时发生的。换句话说，当通用的 swap 模板用于 Widgets 时，就应该使用这个实现。通常，我们改变 std namespace 中的内容是不被允许的，但允许为我们自己创建的类型（就像 Widget）完全特化标准模板（就像 swap）。这就是我们现在在这里做的事情。
可是，就像我说的，这个函数还不能编译。那是因为它试图访问 a 和 b 内部的 pImpl 指针，而它们是 private 的。我们可以将我们的特化声明为友元，但是惯例是不同的：让 Widget 声明一个名为 swap 的 public 成员函数去做实际的交换，然后特化 std::swap 去调用那个成员函数：
```
class Widget { // same as above, except for the
public: // addition of the swap mem func
...
void swap(Widget& other)
{
using std::swap; // the need for this declaration
// is explained later in this Item
swap(pImpl, other.pImpl); // to swap Widgets, swap their
} // pImpl pointers
...
};
namespace std {
template<> // revised specialization of
void swap<Widget>(Widget& a, // std::swap
Widget& b)
{
a.swap(b); // to swap Widgets, call their
} // swap member function
}
```
这个不仅能够编译，而且和 STL 容器保持一致，所有 STL 容器都既提供了 public swap 成员函数，又提供了 std::swap 的特化来调用这些成员函数。
可是，假设 Widget 和 WidgetImpl 是类模板，而不是类，或许因此我们可以参数化存储在 WidgetImpl 中的数据类型：
```
template<typename T>
class WidgetImpl { ... };
template<typename T>
class Widget { ... };
```
在 Widget 中加入一个 swap 成员函数（如果我们需要，在 WidgetImpl 中也加一个）就像以前一样容易，但我们特化 std::swap 时会遇到麻烦。这就是我们要写的代码：
```
namespace std {
template<typename T>
void swap<Widget<T> >(Widget<T>& a, // error! illegal code!
Widget<T>& b)
{ a.swap(b); }
}
```
这看上去非常合理，但它是非法的。我们试图部分特化（partially specialize）一个函数模板（std::swap），但是尽管 C++ 允许类模板的部分特化（partial specialization），但不允许函数模板这样做。这样的代码不能编译（尽管一些编译器错误地接受了它）。
当我们想要“部分特化”一个函数模板时，通常做法是简单地增加一个重载。看起来就像这样：
```
namespace std {
template<typename T> // an overloading of std::swap
void swap(Widget<T>& a, // (note the lack of "<...>" after
Widget<T>& b) // "swap"), but see below for
{ a.swap(b); } // why this isn't valid code
}
```
通常，重载函数模板确实很不错，但是 std 是一个特殊的 namespace，规则对它也有特殊的待遇。它认可完全特化 std 中的模板，但它不认可在 std 中增加新的模板（也包括类，函数，以及其它任何东西）。std 的内容由 C++ 标准化委员会单独决定，并禁止我们对他们做出的决定进行增加。而且，禁止的方式使你无计可施。打破这条禁令的程序差不多的确可以编译和运行，但它们的行为是未定义的。如果你希望你的软件有可预期的行为，你就不应该向 std 中加入新的东西。
因此该怎么做呢？我们还是需要一个方法，既使其他人能调用 swap，又能让我们得到更高效的模板特化版本。答案很简单。我们还是声明一个非成员 swap 来调用成员 swap，只是不再将那个非成员函数声明为 std::swap 的特化或重载。例如，如果我们的 Widget 相关机能都在 namespace WidgetStuff 中，它看起来就像这个样子：
```
namespace WidgetStuff {
... // templatized WidgetImpl, etc.
template<typename T> // as before, including the swap
class Widget { ... }; // member function
...
template<typename T> // non-member swap function;
void swap(Widget<T>& a, // not part of the std namespace
Widget<T>& b)
{
a.swap(b);
}
}
```
现在，如果某处有代码使用两个 Widget 对象调用 swap，C++ 的名字查找规则（以参数依赖查找（argument-dependent lookup）或 Koenig 查找（Koenig lookup）著称的特定规则）将找到 WidgetStuff 中的 Widget 专用版本。而这正是我们想要的。
这个方法无论对于类模板还是对于类都能很好地工作，所以看起来我们应该总是使用它。不幸的是，此处还是存在一个需要为类特化 std::swap 的动机（过一会儿我会讲到它），所以如果你希望你的 swap 的类专用版本在尽可能多的上下文中都能够调用（而你也确实这样做了），你就既要在你的类所在的 namespace 中写一个非成员版本，又要提供一个 std::swap 的特化版本。
顺便提一下，如果你不使用 namespaces，上面所讲的一切依然适用（也就是说，你还是需要一个非成员 swap 来调用成员 swap），但是你为什么要把你的类，模板，函数，枚举（此处作者连用了两个词（enum, enumerant），不知有何区别——译者注）和 typedef 名字都堆在全局 namespace 中呢？你觉得合适吗？
迄今为止我所写的每一件事情都适用于 swap 的作成者，但是有一种状况值得从客户的观点来看一看。假设你写了一个函数模板来交换两个对象的值：
```
template<typename T>
void doSomething(T& obj1, T& obj2)
{
...
swap(obj1, obj2);
...
}
```
哪一个 swap 应该被调用呢？std 中的通用版本，你知道它必定存在；std 中的通用版本的特化，可能存在，也可能不存在；T 专用版本，可能存在，也可能不存在，可能在一个 namespace 中，也可能不在一个 namespace 中（但是肯定不在 std 中）。究竟该调用哪一个呢？如果 T 专用版本存在，你希望调用它，如果它不存在，就回过头来调用 std 中的通用版本。如下这样就可以符合你的希望：
```
template<typename T>
void doSomething(T& obj1, T& obj2)
{
using std::swap; // make std::swap available in this function
...
swap(obj1, obj2); // call the best swap for objects of type T
...
}
```
当编译器看到这个 swap 调用，他会寻找正确的 swap 版本来调用。C++ 的名字查找规则确保能找到在全局 namespace 或者与 T 同一个 namespace 中的 T 专用的 swap。（例如，如果 T 是 namespace WidgetStuff 中的 Widget，编译器会利用参数依赖查找（argument-dependent lookup）找到 WidgetStuff 中的 swap。）如果 T 专用 swap 不存在，编译器将使用 std 中的 swap，这归功于此函数中的 using declaration 使 std::swap 在此可见。尽管如此，相对于通用模板，编译器还是更喜欢 T 专用的 std::swap 的特化，所以如果 std::swap 对 T 进行了特化，则特化的版本会被使用。
得到正确的 swap 调用是如此地容易。你需要小心的一件事是不要对调用加以限定，因为这将影响 C++ 确定该调用的函数，如果你这样写对 swap 的调用，
```
std::swap(obj1, obj2); // the wrong way to call swap
```
这将强制编译器只考虑 std 中的 swap（包括任何模板特化），因此排除了定义在别处的更为适用的 T 专用版本被调用的可能性。唉，一些被误导的程序员就是用这种方法限定对 swap 的调用，这也就是为你的类完全地特化 std::swap 很重要的原因：它使得以这种被误导的方式写出的代码可以用到类型专用的 swap 实现。（这样的代码还存在于现在的一些标准库实现中，所以它将有利于你帮助这样的代码尽可能高效地工作。）
到此为止，我们讨论了缺省的 swap，成员 swaps，非成员 swaps，std::swap 的特化版本，以及对 swap 的调用，所以让我们总结一下目前的状况。
首先，如果 swap 的缺省实现为你的类或类模板提供了可接受的性能，你不需要做任何事。任何试图交换你的类型的对象的人都会得到缺省版本的支持，而且能工作得很好。
第二，如果 swap 的缺省实现效率不足（这几乎总是意味着你的类或模板使用了某种 pimpl idiom 的变种），就按照以下步骤来做：
1\. 提供一个能高效地交换你的类型的两个对象的值的 public 的 swap 成员函数。出于我过一会儿就要解释的动机，这个函数应该永远不会抛出异常。
2\. 在你的类或模板所在的同一个 namespace 中提供一个非成员的 swap。用它调用你的 swap 成员函数。
3\. 如果你写了一个类（不是类模板），就为你的类特化 std::swap。用它也调用你的 swap 成员函数。
最后，如果你调用 swap，请确保在你的函数中包含一个 using declaration 使 std::swap 可见，然后在调用 swap 时不使用任何 namespace 限定条件。
唯一没有解决的问题就是我的警告——绝不要让 swap 的成员版本抛出异常。这是因为 swap 的非常重要的应用之一是为类（以及类模板）提供强大的异常安全（exception-safety）保证。Item 29 将提供所有的细节，但是这项技术基于 swap 的成员版本绝不会抛出异常的假设。这一强制约束仅仅应用在成员版本上！它不能够应用在非成员版本上，因为 swap 的缺省版本基于拷贝构造和拷贝赋值，而在通常情况下，这两个函数都允许抛出异常。如果你写了一个 swap 的自定义版本，那么，典型情况下你是为了提供一个更有效率的交换值的方法，你也要保证这个方法不会抛出异常。作为一个一般规则，这两种 swap 的特型将紧密地结合在一起，因为高效的交换几乎总是基于内建类型（诸如在 pimpl idiom 之下的指针）的操作，而对内建类型的操作绝不会抛出异常。
Things to Remember
* 如果 std::swap 对于你的类型来说是低效的，请提供一个 swap 成员函数。并确保你的 swap 不会抛出异常。
* 如果你提供一个成员 swap，请同时提供一个调用成员 swap 的非成员 swap。对于类（非模板），还要特化 std::swap。
* 调用 swap 时，请为 std::swap 使用一个 using declaration，然后在调用 swap 时不使用任何 namespace 限定条件。
* 为用户定义类型完全地特化 std 模板没有什么问题，但是绝不要试图往 std 中加入任何全新的东西。
- Preface（前言）
- Introduction（导言）
- Terminology（术语）
- Item 1: 将 C++ 视为 federation of languages（语言联合体）
- Item 2: 用 consts, enums 和 inlines 取代 #defines
- Item 3: 只要可能就用 const
- Item 4: 确保 objects（对象）在使用前被初始化
- Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数
- Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝
- Item 7: 在 polymorphic base classes（多态基类）中将 destructors（析构函数）声明为 virtual（虚拟）
- Item 8: 防止因为 exceptions（异常）而离开 destructors（析构函数）
- Item 9: 绝不要在 construction（构造）或 destruction（析构）期间调用 virtual functions（虚拟函数）
- Item 10: 让 assignment operators（赋值运算符）返回一个 reference to *this（引向 *this 的引用）
- Item 11: 在 operator= 中处理 assignment to self（自赋值）
- Item 12: 拷贝一个对象的所有组成部分
- Item 13: 使用对象管理资源
- Item 14: 谨慎考虑资源管理类的拷贝行为
- Item 15: 在资源管理类中准备访问裸资源（raw resources）
- Item 16: 使用相同形式的 new 和 delete
- Item 17: 在一个独立的语句中将 new 出来的对象存入智能指针
- Item 18: 使接口易于正确使用，而难以错误使用
- Item 19: 视类设计为类型设计
- Item 20: 用 pass-by-reference-to-const（传引用给 const）取代 pass-by-value（传值）
- Item 21: 当你必须返回一个对象时不要试图返回一个引用
- Item 22: 将数据成员声明为 private
- Item 23: 用非成员非友元函数取代成员函数
- Item 24: 当类型转换应该用于所有参数时，声明为非成员函数
- Item 25: 考虑支持不抛异常的 swap
- Item 26: 只要有可能就推迟变量定义
- Item 27: 将强制转型减到最少
- Item 28: 避免返回对象内部构件的“句柄”
- Item 29: 争取异常安全（exception-safe）的代码
- Item 30: 理解 inline 化的介入和排除
- Item 31: 最小化文件之间的编译依赖
- Item 32: 确保 public inheritance 模拟 "is-a"
- Item 33: 避免覆盖（hiding）“通过继承得到的名字”
- Item 34: 区分 inheritance of interface（接口继承）和 inheritance of implementation（实现继承）
- Item 35: 考虑可选的 virtual functions（虚拟函数）的替代方法
- Item 36: 绝不要重定义一个 inherited non-virtual function（通过继承得到的非虚拟函数）
- Item 37: 绝不要重定义一个函数的 inherited default parameter value（通过继承得到的缺省参数值）
- Item 38: 通过 composition（复合）模拟 "has-a"（有一个）或 "is-implemented-in-terms-of"（是根据……实现的）
- Item 39: 谨慎使用 private inheritance（私有继承）
- Item 40: 谨慎使用 multiple inheritance（多继承）
- Item 41: 理解 implicit interfaces（隐式接口）和 compile-time polymorphism（编译期多态）
- Item 42: 理解 typename 的两个含义
- Item 43: 了解如何访问 templatized base classes（模板化基类）中的名字
- Item 44: 从 templates（模板）中分离出 parameter-independent（参数无关）的代码
- Item 45: 用 member function templates（成员函数模板） 接受 "all compatible types"（“所有兼容类型”）
- Item 46: 需要 type conversions（类型转换）时在 templates（模板）内定义 non-member functions（非成员函数）
- Item 47: 为类型信息使用 traits classes（特征类）
- Item 48: 感受 template metaprogramming（模板元编程）
- Item 49: 了解 new-handler 的行为
- Item 50: 领会何时替换 new 和 delete 才有意义
- Item 51: 编写 new 和 delete 时要遵守惯例
- Item 52: 如果编写了 placement new，就要编写 placement delete
- 附录 A. 超越 Effective C++
- 附录 B. 第二和第三版之间的 Item 映射