《Effective C++ 中文版 第三版》读书笔记
** 条款 25：考虑写出一个不抛异常的 swap 函数 **
缺省情况下 swap 动作可由标准程序库提供的 swap 算法完成：
namespace std{
template<typename T>
void swap(T& a, T& b)
{
T temp(a);
a = b;
b = temp;
}
}
但是对某些类型而言，这些复制动作无一必要：其中主要的就是“以指针指向一个对象，内含真正数据”那种类型。多为 “pimpl 手法”（pointer to implementation 的缩写）。设计 Widget class：
class WidgetImpl
{
public:
...
protected:
...
private:
int a, b, c;
std::vector<double> v;
...
};
class Widget
{
public:
Widget(const Widget& rhs);
Widget& operator=(const Widget& rhs)
{
...
*pImpl = *(rhs.pImpl);
}
protected:
private:
WidgetImpl* pImpl;
};
要置换两个 Widget 对象值，唯一要做的就是置换 pImpl 指针，缺省的 swap 算法不知道这一点。不只复制 3 个 Widget 还复制 3 个 WidgetImpl 对象。非常缺乏效率！
我们可以将 std::swap 全特化：
namespace std{
template<>
void swap<Widget>(Widget& a, Widget& b)
{
swap(a.pImpl, b.pImpl); //< 不能通过编译，访问 private 成员变量
}
}
虽然可以把这个特化版本声明为 friend，但这和以往的规矩不太一样，我们可以令 Widget 声明一个 swap 的 public 成员函数做真正的替换工作，然后将 std::swap 特化，令他调用该成员函数：
class Widget
{
public:
Widget(const Widget& rhs);
Widget& operator=(const Widget& rhs)
{
...
*pImpl = *(rhs.pImpl);
}
void swap(Widget& other)
{
using std::swap;
swap(pImpl, other.pImpl);
}
protected:
private:
WidgetImpl* pImpl;
};
namespace std{
template<>
void swap<Widget>(Widget& a, Widget& b)
{
a.swap(b);
}
}
假设 Widget 和 WidgetImpl 都是 class templates 而非 classes：
template <typename T>
class WidgetImpl{…};
template <typename T>
class Widget{…};
在特化std::swap时：
namespace std{
template<typename T>
void swap<Widget<T>>(Widget<T>& a, Widget<T>& b) //wrong！不合法！
{
a.swap(b);
}
}
我们企图偏特化一个 function template，但是 c++ 中只允许对 class templates 偏特化，在 function template 身上偏特化是行不通的。这段代码不该通过编译（虽然有些编译器错误地接受了它）。
当打算偏特化一个 function template 时，惯常的做法是简单的为它添加一个重载版本：
namespace std{
template<typename T>
void swap(Widget<T>& a, Widget<T>& b) //注意“swap后没有<>”
{
a.swap(b);
}
}
一般而言，重载 function template 没有问题，但 std 是个特殊的命名空间，管理也就比较特殊。客户可以全特化 std 内的 templates，但不可以添加新的 templates（或 class 或 function 或任何其他东西）到 std 里头。其实跨越红线的程序几乎仍可编译执行，但他们行为没有明确定义。所以不要添加任何新东西到 std 里头。
未提供较高效的 template 特定版本。我们还是声明一个 non-member swap 但不再是 std::swap 的特化版本或重载版本：
``cpp
namespace WidgetStuff{
template<typename T>
class Widget{...};
template<typename T>
void swap(Widget<T>& a, Widget<T>& b)
{
a.swap(b);
}
}
现在，任何地点的任何代码如果打算置换两个 Widget 对象，因而调用 swap，C++ 的名称查找法则就是所谓 “argument-dependent lookup” 会找到 WidgetStuff 内的专属版本。
```cpp
template<typename T>
void doSomething(T& obj1, T& obj2)
{
...
swap(obj1, obj2);
...
}
上面的应该使用哪个 swap？是 std 既有的那个一般化版本还是某个可能存在的特化版本等？你希望应该是调用 T 专属版本，并在该版本不存在的情况下调用 std 内的一般化版本，下面是你希望发生的事：
template<typename T>
void doSomething(T& obj1, T& obj2)
{
using std::swap; //< 令 std::swap 在此函数内可用
...
swap(obj1, obj2); //< 为 T 型对象调用最佳 swap 版本
...
}
c++ 的名称查找法则（name lookup rules）确保将找到 global 作用域或 T 所在之命名空间内的任何 T 专属的 swap。如果 T 是 Widget 并且位于命名空间 WidgetStuff 内，编译器会找出 WidgetStuff 内的 swap。如果没有 T 专属的 swap 存在，编译器就是用 std 内的 swap，然而即便如此，编译器还是比较喜欢 std::swap 的 T 专属特化版本，而非一般化的那个 template。
std::swap(obj1,obj2); //< 这是错误的 swap 调用方式
这便强迫编译器只认 std 内的 swap（包括其任何 template 特化），因此不再调用一个定义于他处的较适当 T 专属版本。那正是“你的 classes 对 std::swap 进行全特化的”重要原因：使得类型专属的 swap 实现版本可以被这些迷途代码所用。
如果 swap 的缺省实现码对你的 classes 或 class template 提供可接受的效率，不需要额外做任何事。
如果 swap 缺省实现版效率不足（某种 pimpl)：
- 提供一个 public swap 成员函数，这个函数绝不该抛出异常。
- 在 class 或 template 所在的命名空间内提供一个 non-member swap， 并令他调用上述 swap 成员函数。
- 如果正编写一个 class（而非 class template），为你的 class 特化 std::swap。并令他调用 swap 成员函数。
如果调用 swap，确保包含一个 using 声明式，然后不加任何 namespace 修饰符，赤裸裸调用 swap。
成员版 swap 绝不可抛出异常。
唯一还未明确的劝告：成员版本的 swap 决不可抛出异常。那是因为 swap 的一个最好的应用是帮助 classes（class templates）提供强烈的异常安全性保障。（条款 29 对此提供了所有细节）此技术基于一个假设：成员版的 swap 绝不抛出异常。这一约束只施行于成员版！不可施行于非成员版，因为 swap 缺省版本是以 copy 构造函数和 copy assignment 操作符为基础，而一般情况下两者都允许抛出异常。因此当你写一个自定版本的 swap，往往提供的不只是高效置换对象值的办法，而且不抛出异常。一般，这两个 swap 特性是连在一起的，因为高效的 swaps 几乎总是基于对内置类型的操作（例如 pimpl 手法的底层指针），而内置类型上的操作绝不会抛出异常。
** 请记住： **
- 当 std::swap 对你的类型效率不高时，提供一个 swap 成员函数，并确定这个函数不抛出异常。
- 如果你提供一个 member swap，也该提供一个 non-member swap 用来调用前者。对于 class（而非 template），也请特化 std::swap。
- 调用 swap 时应针对 std::swap 使用 using 声明式，然后调用 swap 并且不带任何“命名空间资格修饰符”。
- 为“用户定义类型”进行 std template 全特化是好的，但千万不要尝试在 std 内加入某些对 std 而言全新的东西。
