Effective C++笔记_条款25考虑写出一个不抛出异常的swap函数

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

// 缺点：需要赋值大量的数据,但是有的时候并不要复制如此多的内容
class WidgetImpl {
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:
    WidgetImpl *pImpl;
};

// 对于上面这个实例来说，只需要交换指针就好了，没有必要进行全部的值的交换。
// 为了解决这个问题，需要将std::swap针对Widget特化。说白一点就是专门为Widget
// 设计一个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);
    }

private:
    WidgetImpl *pImpl;
};

// 注意哟，下面是针对Widget类的特化swap，它调用Widget的swap函数
namespace std {
    template<>       // 1.全特化
    void swap<Widget>(Widget& a, Widget& b)   // 2.表明这个swap函数专门给Widget特化的
    {
        a.swap(b);
    }
}

// 面对class templates 又如何呢
template<typename T>
class WidgetImpl {
    //...
};

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

/*
 错误哟：C++只允许对class templates 偏特化，在function templates偏特化是行不通的
 客户可以全特化std内的templates(template<>),但是不可以添加新的templates(或classes
 或functions或其他任何东西)到std里头。
*/
namespace std {
    template<typename T>
    void swap< Widget<T> > (Widget<T>& a, Widget<T>& b)
    {
        a.swap(b);     
    }
};

// ----- solution  -----
namespace WidgetStuff {
    class WidgetImpl {
    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);
            //....
        }

        // 注意哟，重点到了.实现真正的置换工作
        void swap(Widget& other)
        {
            using std::swap;
            swap(pImpl, other.pImpl);
        }

    private:
        WidgetImpl *pImpl;
    };

    template<typename T>
    void swap(Widget<T>& a, Widget<T>& b)
    {
        a.swap(b);                   // 调用Widget中的swap函数
    }
}

总结：　

        当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。

        如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于classes（而非templates），也请特化std::swap。

        调用swap时应该针对std::swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰”。

        为“用户定义类型”进行std template 全特化是好的，但千万不要尝试在std内加入某些std而言全新的东西。