条款25：考虑写出一个不抛出异常的swap函数

1.前言

swap是个有趣的函数，原本它只是STL的一部分，而后成为异常安全编程的基石，以及用来处理自我赋值可能性的一个常见机制。由于swap功能如此强大，适当的实现很重要。然而在非凡的重要性之外它也带来了非凡的复杂度。

所谓swap两对象值，意思是将两对象的值彼此赋予对方。缺省情况下swap动作可由标准程序库提供的swap算法完成。其典型的实现方式如下：

namespace std{

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

只要类型T支持copying(通过copy构造函数和copy assignment操作符完成)，缺省的swap实现代码就会帮你置换类型为T的对象，不需要为此做另外的工作。

该缺省的swap实现版本十分平淡，无法刺激你的肾上腺。它涉及到三个对象的复制：a复制到temp,b复制到a,以及temp复制到b。但是对于某些类型而言，这些复制动作没有必要：对那种情况而言swap缺省行为等于杀机用牛刀。

2.实例

最主要的一种类型就是“以指针指向一个对象，内含真正数据”那种类型。这种设计的常见表现形式就是所谓的“pimpl手法”。如果以这种手法设计Widget class，看起来像这样：

class WidgetImpl{   //针对Widget数据而设计的class

public:
...
private:
int a,b,c;//可能有许多数据
std::vector<double> v;//意味复制时间很长
....

};

class Widget{

public:
    Widget(const Widget& rhs);
    Widget& operator=(const Widget& rhs)
    {
        ...
        *pImpl=*(rhs.pImpl);
    }
    ...
 private:
    Widget Impl* pImpl;//指针，所有对象内含Widget
}

一旦要置换两个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);
    }
}    

这个函数一开始得"template<>"表示它是std::swap的一个全特化版本，函数名称之后的"<Widget>"表示这一特化版本系针对“T是Widget”而设计。换句话说当一般性的swap template施行于Widget身上便会启用这个版本。通常我们不能够改变std命名空间内的任何东西，但可以为标准template制造特化版本，使它专属于我们自己的classes。

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

class Widget{

    public:
        ...
        void swap(Widget& other)
        {
            using std::swap;
            swap(pImpl,other.pImpl);//若要置换Widgets就置换其pImpl指针

        }
        ...
};
namespace std{

    template<>
    void swap<Widget>(Widget& a,Widget& b){
        a.swap(b);//若要置换Widgets，调用其swap成员函数

}
}

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

然而假设Widget和WidgetImpl都是class templates而非classes,也许我们可以将Widget内的数据类型加以参数化：

template<typename T>
class WidgetImpl{...};
template<typename T>
class Widget{....};

在Widget内放个swap成员函数就像以往一样简单，但我们却在特化std::swap时遇上乱流，我们想编写成这样：

namespace std{

    template<typename T>
    void swap<Widget<T>> (Widget<T>& a,Widget<T>& b){//错误，不合法
        a.swap(b);    
    }
}

 看起来合情合理，却不合法。我们企图偏特化一个function template，但c++只允许对class template偏特化，在function template身上偏特化是行不通的。这段代码不该通过编译。

当打算特偏化一个function template时，惯常做法是简单地为它添加一个重载版本，像这样：

namespace std{
    template<typename T>//std::swap的一个重载版本
    void swap(Widget<T>& a,Widget<T>& b){
        a.swap(b);
    }
}

一般而言，重载function template没有问题，但std是个特殊的命名空间，其管理规则也比较特殊，客户完全可以全特化std内的templates，但不可以添加新的templates到std里头。