不抛出异常的swap

#include<iostream>

using namespace std;
/*
1.提供一个public swap成员函数，让它 高效地置换你的 类型 的 两个成员对象 （绝不会抛出异常）
2.在class 或 template 所在 命名空间 内 提供 一个 non-member swap（非成员 函数 的 swap)， 并 令它 调用swap 成员函数
3.为正在 编写的 类 class （非 class template），为你的 class 特化std::swap,并 令它 调用swap 成员函数
4.如果你调用swap （例如 ：在 dosomething函数 中 调用 swap函数 ），包含一个using 声明式 ,让std::swap在函数内曝光可见
*/
/*
成员版本swap绝不可抛出异常
swap缺省版本 是以 copy构造函数 和  copy assignment操作符 为基础 （一般 两者 都允许 抛出异常）
自定义 swap （1）高效置换对象值 （2）不抛出异常 
             （1）高效 基于 内置类型的 操作 （例如 pipml 手法的 底层指针） （2）内置类型的 操作 绝不会 抛出异常
*/
namespace WidgetStuff
{
    template<typename T>
    class WidgetImp1
    {

    };
    template<typename T>
    class Widget
    {
        public:
        Widget()
        {

        }
        Widget(const Widget<T>&rhs)
        {

        }
        Widget & operator =(const Widget<T> &rhs)
        {
            *pImp1 = *rhs.pImp1;
        }
        void swap(Widget &other)
        {
            using std::swap;
            swap(pImp1,other.pImp1);
        }
        public:
        WidgetImp1<T> *pImp1;
    };
    /*template <typename T>
    void swap(Widget<T> &a,Widget<T> &b)
    {
        a.swap(b);
        cout<<"WidgetStuff:: void swap(Widget<T> &a,Widget<T> &b)"<<endl;
    }*/
};
namespace std/*std::模板特化版本*/
{
    using namespace WidgetStuff;
    template<>
    void swap(Widget<int> &a,Widget<int> &b)/*模板的全特化*/
    {
        cout<<"std:: void swap(Widget<int> &a,Widget<int> &b)"<<endl;
        a.swap(b);
    }
};
template<typename T>
void dosomething(T &obj1,T &obj2)
{
    using std::swap;/*让std::swap在函数内曝光可见*/
    swap(obj1,obj2);
    /*名称查找法则（确保将找到global作用域 或 T所在命名空间内任何T专属的swap*/
    /*如果T是widget 并 位于 命名空间widgetstuff 内 ，
    编译器会使用“ 实参取决之查找规则” 找出 widgetstuff 内的 swap，
    如果没有T专属之swap存在，编译器就会使用std内的swap
    感谢using声明式让std::swap在函数内曝光*/
}

int main()
{
    using namespace WidgetStuff;
    Widget<int> a;
    Widget<int> b;
    swap(a,b);
    dosomething(a,b);
    return 0;
}