swap

我就是对swap为什么在类内定义一个成员函数，然后在外面定义一个非成员来调用它迷惑！
我觉得我们的初衷是面对pimpl（指针实现的class）才去定义自己版本的swap。
而按照之前类的思想，类内函数，类外实现，类内调用类外也没差，错就错在这思想上，你现在做的工作是有个swap<>,当用它swap class,会先去找一个特例化的实现，由于是交换指针，而非对象，所以又进一步去调用成员swap，搜嘎！

#include <iostream>


class WidgetImpl
{
public:   //设计是针对Widget数据


private:
int i, j, m;
};


class Widget
{
public:
Widget() = default;
Widget(const Widget& other);//为什么不定义，不定义能用吗？
/*{
pImpl = other.pImpl;
}*/


void swap(Widget& other)
{
using std::swap;
swap(pImpl, other.pImpl);
}
//Widget& operator= (const Widget& other)
//{
// *pImpl = *(other.pImpl);
//}//看看自己写的是什么？
没有考虑自赋值！没有返回this！
Widget& operator= (Widget& s)
{
if (this != &s)
{
Widget temp(s);
//swap(*this, s); // 顺眼多了，会先去调用特化版本的swap
(*this).swap(s);
}
return *this;
}
~Widget()
{


}
private:
WidgetImpl* pImpl;
};
namespace std {  // 这是添加的全特例的一种方法，应该是
template<>
void swap<Widget>(Widget &lhs, Widget &rhs)
{
lhs.swap(rhs);
}
}
//下来是模板class
namespace my {//偏特例化 相当于一个模板了，所以不能在std中，所以要定义自己的namespace
template<typename T>
class WidgetImpl1 {
//null
};
template<typename T>
class Widget1 {
//null
};
}
void main()
{


}

1. 在类中提供了一个public swap成员函数，这个函数直接交换指针本身（因为指针本身是int类型的，所以会调用std的普通swap函数），像下面这样：
   void Sample::swap(Sample &s)
{
swap(p, s.p); // 也可以写成std::swap(this->p, s.p);
}
   
   1. 在与Sample在同一个namespace的空间里提供一个non-member swap，并令他调用成员函数里的swap，像下面这样：

1 template <>
2 void swap(Sample& s1, Sample& s2){s1.swap(s2);} // 如果Sample是普通类，则定义swap位于mysample空间中，同时多定义一个位于std空间中（这个多定义不是必须的，只是防御式编程）
或者

1 template
2 void swap(Sample& s1, Sample& s2){s1.swap(s2);} // 如果Sample是模板类时，只能定义在mysample空间中