C/C++编程：考虑写出一个不抛异常的swap函数

swap是个有趣的函数。原本它只是STL的一部分，而后成为异常安全性编程的脊柱，以及用来实现自我赋值可能性的一个常见机制。

原理

所谓swap两对象值，就是将两对象的值交换。缺省情况下的swap动作可有标准库提供的swap算法完成。典型实现如下：

namespace std{
	template<typename T>
	void swap(T & a, T & b){
		T temp(a);
		a = b;
		b = temp;
	}
};

只要类型T支持拷贝(通过拷贝构造函数和拷贝运算符)，缺省的swap就可以完成交换两相同类型的对象的值，你不需要为此做任何动作。

上面版本的实现调用了三次拷贝，对于某些类型而言，太慢了。典型的就是"以指针指向一个对象，内含指针数据"的那种类型。这种设计的常见表现形式就是"pimpl（pointer to implementation）手法"。如果以这种手法设计Widget类，看起来会像这样：

class WidgetImpl{
private:
	int a, b, c;
	std::vector<double> v; // 可能有很多数据，意味着复制时间很长
};

class Widget{  // 这个类使用pimpl手法
public:
	Widget(const WidgetImpl& rhs);
	Widget& operator=(const Widget& rhs){ //复制Widget时，令它复制其WidgetImpl对象
		...
		*pImpl = *(rhs.pImpl);
	}

private:
	WidgetImpl * pImpl;
}

一旦要置换两个Widget对象的值，我们唯一要做的是交换其pImpl指针，但是缺省的swap不知道这一点。它不止复制三个Widgets，还复制三个WidgetImpl 对象。非常缺乏效率。

我们希望能够告诉std::swap：当Widget被置换时真正该做的是置换其内部的pImpl指针。确切实现这个思路的一个做法是：将std::swap针对Widget特化。下面是基本构想，但目前这个形式无法通过编译：

namespace std{
	template<>
	void swap<Widget>(Widget&a, Widget&b){
		swap(a.pImpl, b.pImpl);  // 只需要交换它们的pImpl指针就好
	};
};

这个函数一开始的template<>表示它是std::swap的一个全特化版本，函数名称后面的<Widget>表示这一特化版本是针对"T是Widget"而设计。换句话说当一般性的swap模板施行于Widget身上就会启用这个版本。通常我们不被允许改变std命名空间内的任何东西，但可以为标准模板(比如swap)制作特化版本，使它专属于我们自己的类(比如Widget)

但是这个版本无法通过编译，因为它企图访问a和b内的的private pImpl指针。我们可以将这个特化版本声明为友元，但是和以往不一样：我们令Widget声明一个名为swap的public成员函数做真正的置换工作，然后将std::swap特化，令它调用该函数：

class Widget{ 
public:
	...
	void swap(Widget& other){
		using std::swap;     
		swap(pImpl, other.pImpl);
	}
}

namespace std{
	template<>
	void swap<Widget>(Widget &a, Widget & b){
		a.swap(b);
	}
};

这种做法不止能够通过编译，还与STL容器有一致性，因为所有STL容器也都提供有public swap成员函数和std::swap特化版本.

假如Widget、WidgetImpl但是类模板而不是类，这时候我们可以尝试将WidgetImpl内的数据类型加以参数化：

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);
    }
};

但是无法通过编译：因为C++只允许对类模板偏特化，不允许在函数模板身上偏特化。如果你打算偏特化一个函数模板，常用做法是简单的为它添加一个重载版本：

namespace std{
    template<typename T>
    void swap(Widget<T> &a, Widget<T> & b){
        a.swap(b);
    }
};

一般来说，重载函数模板没有问题，但是std是个特殊的命名空间，其管理规则也特殊：客户可以全特化std内的模板，但是不可以添加新的模板到std里面。std的内容完全由C++标准委员会决定。虽然上面可以通过编译，但是行为未定义。

那怎么办？解决方法：声明一个non-member swap让它调用member swap，但不再将那个non-member swap声明为std的特化版本

namespace WidgetStuff{
	... // 模板化的WidgetImpl等等
	template<typename T>
	class Widget{...};  //同前，内含swap成员函数
	...
	template<typename T>  //non-member  swap函数
	void swap(Widget<T>&a, Widget<T>&b){
			a.swap(b);
	}
};

总结

首先，如果swap的缺省实现码对你的类或者类模板提供可接受的效率，你不需要做任何事情。任何尝试交换对象的人将使用缺省版本达到目的

其次，无关swap缺省实现版的效率不足(那几乎总是意味着你的类或者模板使用了某种pimpl手法)，试着做如下事情：

• 提供一个public swap成员函数，让他搞笑的置换你的类型的两个对象值。这个函数就不该抛出异常
• 在你的类或者模板所在的命名空间内提供一个non-member swap，并令它调用上面的swap成员函数
• 如果你正在编写一个类(而不是类模板)，为你的类特化std::swap。并令它调用你的swap成员函数。
• 最后，如果你调用swap，请确定包含一个using声明式，以便让你的std::swap在你的函数内曝光可见，然后不加任何namespace修饰符，赤裸裸的调用swap

请记住

• 当你的std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常(为这个类提供强烈的异常安全性)
• 如果你提供一个成员swap，也该提供一个non-member swap来调用前者。对于类(注意不是模板)，也请特化std::swap
• 调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何"命名空间资格修饰"
• 为"用户自定义类型"进行std模板全特化是好的，但是千万不要在std内加入某些对std而言全新的东西