本文共 4213 字，大约阅读时间需要 14 分钟。

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首发的底层指针），而内置类型上的操作绝不会抛出异常。

转载地址：http://efgq.baihongyu.com/