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

条款25:考虑写出一个不抛异常的swap函数
swap函数在C++中是一个非常重要的函数，但实现也非常复杂。
看一个缺省的std::swap函数的实现

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

①内置类型的调用

int a = 2;
int b =3;
std::swap(a, b);
cout<<"a:"<<a<<" b:"<<b<<endl;

②非内置类型的调用
自我定义的类类型需要实现拷贝构造函数和拷贝赋值函数才能执行swap。
swap的实现：a先调用拷贝构造函数创建temp，通过拷贝赋值函数将b赋给a，再通过赋值函数将temp赋给b；
但对于另一种类的定义："以指针指向一个对象，内含真正数据"那种类型，这种设计的常见表现形式是所谓"pimpl 手法"，即把数据寄托在另外一个类中。如果采用默认的swap函数，会出现什么状况？

class WigetImpl
{
public:
WigetImpl(const int v) : m_value(v){ }
int GetValue() const {return m_value;}
private:
int m_value;
};

class Wiget
{
public:
Wiget(const int v) {m_impl = new WigetImpl(v);}
~Wiget() {if (m_impl != NULL) delete m_impl; m_impl = NULL;}

Wiget(const Wiget &wiget)
{
this->m_impl = new WigetImpl(wiget.m_impl->GetValue());
}

Wiget& operator = (const Wiget &wiget)
{
if (this != &wiget) {   //采用copy-and-swap技术会更好，参考前面条款
*m_impl = *wiget.m_impl;
}

return *this;
}
private:
WigetImpl *m_impl;
};

调用

Wiget w1(2);
Wiget w2(3);
std::swap(w1, w2);

调用缺省的swap，不但需要调用三次Wiget的copy函数，还调用三次WigetImpl的copy函数，效率非常低。

我们希望能够告诉std:: swap: 当Widgets 被置换时真正该做的是置换其内部的m_impl指针。确切实践这个思路的一个做法是将std: :swap 针对Widget 特化,即全特化。

namespace std
{
template<>
void swap<Wiget>(Wiget &a,Wiget &b)
{
a.swap(b);  //调用Wiget的swap函数
}
}

在Wiget中定义一个swap函数，实现对m_impl指针交换

void swap(Wiget & rhl)
{
std::swap(this->m_impl, rhl.m_impl);
}

这样调用只是调用三次WigetImpl的copy函数。

假设Wiget和WigetImpl都是一个类模板，如下面

template<typename T>
class WigetImpl {};
template<typename T>
class Wiget{};

我们对函数进行偏特化

namespace std
{
template<typename T>
void swap<Wiget<T> >(Wiget<T> &lhs, Wiget<T> &rhs)
{
lhs.swap(rhs);
}
}

但C++只对类偏特化，函数会报错，如：“std::swap”: 非法使用显式模板参数
解决函数偏特化问题，即修改为函数重载，如下：

namespace std
{
template<typename T>
void swap(Wiget<T> &lhs, Wiget<T> &rhs)
{
lhs.swap(rhs);
}
}

但std是个特殊的命名空间，可以全特化std内的template，但不能添加新的template到std。
这些，都可以通到定义一个no-member function解决，不属于std的命名空间

template<typename T>
void swap(Wiget<T> &lhs, Wiget<T> &rhs)
{
lhs.swap(rhs); //调用Wiget的swap函数
}

上面介绍了3中swap:
①std的缺省swap
②std的特化版本
③class命名空间的no-member swap
那么它们的调用顺序是怎么样呢？为了保证调用顺序是③②①，需要在函数中声明std命名空间

template<typename T>
void CallSwap(T &obj1, T &obj2)
{
<span style="white-space:pre">	</span>using std::swap;
<span style="white-space:pre">	</span>swap(obj1, obj2);
}

相关的原理，可以查看C++名称查找法则
总结swap的使用规则：
首先，如果swap的缺省实现为你的类或类模板提供了可接受的性能，你不需要做任何事。任何试图交换类型的对象的操作都会得到缺省版本的支持，而且能工作得很好。

第二，如果swap缺省实现效率不足（这几乎总是意味着你的类或模板使用了某种pimpl手法），就按照以下步骤来做：

1.提供一个public的swap成员函数，能高效地交换你的类型的两个对象值，这个函数应该永远不会抛出异常。

2.在你的类或模板所在的同一个namespace中，提供一个非成员的swap，用它调用你的swap成员函数。

3.如果你写了一个类（不是类模板），为你的类特化std::swap，并令它调用你的swap 成员函数。

最后，如果你调用swap，确保在你的函数中包含一个using 声明式使std::swap可见，然后在调用swap时不使用任何namespace修饰符
绝不要让swap的成员版本抛出异常。这是因为swap非常重要的应用之一是为类（以及类模板）提供强大的异常安全（exception-safety）保证。

贴出最终的测试代码

template<typename T>
class WigetImpl
{
public:
WigetImpl(const T v) : m_value(v){ }
T GetValue() const {return m_value;}
private:
T m_value;
};

template<typename T>
class Wiget
{
public:
Wiget(const T v) {m_impl = new WigetImpl<T>(v);}
~Wiget() {if (m_impl != NULL) delete m_impl; m_impl = NULL;}

Wiget(const Wiget &wiget)
{
this->m_impl = new WigetImpl<T>(wiget.m_impl->GetValue());
}

Wiget& operator = (const Wiget &wiget)
{
if (this != &wiget) {   //采用copy-and-swap技术会更好，参考前面条款
*m_impl = *wiget.m_impl;
}

return *this;
}

void swap(Wiget & rhl)
{
std::swap(this->m_impl, rhl.m_impl);
}

private:
WigetImpl<T> *m_impl;
};

namespace std
{
template<>
void swap<Wiget<int> >(Wiget<int> &a,Wiget<int> &b)
{
a.swap(b);  //调用Wiget的swap函数
}
}

template<typename T>
void swap(Wiget<T> &lhs, Wiget<T> &rhs)
{
lhs.swap(rhs);
}

template<typename T>
void CallSwap(T &obj1, T &obj2)
{
using std::swap;
swap(obj1, obj2);
}

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

②如果你提供一个member swap,也该提供一个non-member swap用来调用前者.对于classes(而非template),

也请特化std::swap.

③调用swap时应针对std::swap使用using声明式,然后调用swap并且不带任何""命名空间资格修饰.

④为"用户定义类型"进行std templates全特化是好的,但千万不要尝试在std内加入某些std而言全新的东西.