copy-and-swap改进"异常安全"

在了解到异常安全的重要性的重要性后，马上想到自己在刚学C++的时候，在单链表上所做的尝试，记得那个惨不忍睹的赋值函数是这样写的：

template <class Temp>    LinkList<Temp> &  LinkList<Temp>::operator=(LinkList<Temp> &List)    {            DestoryList();            LinkNode<Temp> *p = List.Head;            LinkNode<Temp> *h = Head;            while (p != NULL)            {                LinkNode<Temp> *t = new LinkNode<Temp>;                if(t==NULL)                {                 cerr << "error !" << endl;                 exit(1);                }                h->next = t;                t->data = p->data;                p = p->next;                h = h->next;            }            return *this;    }

如果new不抛出异常，正常的运行没什么大的问题，但是当new抛出异常时，那么就完蛋了。在抛出异常之前，原本的数据就已经被摧毁了，虽说会抛出异常，程序也会被终止（如果真能检测到的话，不过就上述代码似乎没什么机会），然而从“异常安全性”的角度来看，这个函数依旧是个非常糟糕的函数（其他问题先不提O(∩_∩)O~）

根据Effective C++ 中所述，“异常安全”需要满足两个条件

□ 不泄露任何资源
□ 不允许数据被破坏

而有效的异常安全函数(Exception-safe functions)提供如下三个保证之一：

★ 基本承诺： 如果异常被抛出，程序内的任何事物仍然保持在有效的状态下。没有任何对象和数据结构会因该函数调用而被破坏，所有对象都处于一种前后的一致状态。对于上述赋值函数，如果不对抛出的bad_alloc处理的话，那个这个单链表只剩一个空的头结点，虽然此时会指向一个不存在的结点，但是依旧保留了单链表的基本结构。

★ 强烈保证： 如果异常被抛出，程序状态不改变。调用这样的函数需要有这样的认知： 如果函数成功，就是完全成功；如果函数失败，程序回复到“调用函数之前的状态”的状态。（就像以前打BOSS之前先存个档，输了就读档一样）

★ 不抛出保证： 承诺绝不抛出异常，因为他们总是能够完成他们原先承诺的功能，比如给new提供一个nothrow保证。

从这里来看，似乎能够“读档”的强烈保证似乎是一个不错的保证，因此有必要了解一个有效的方法，这个策略被称为copy and swap。简单来说：为原本打算修改的对象（原件）作出一份副本，然后在那副本上做一切有必要的修改，若在修改的动作抛出异常，则保持原对象为改变的状态。待修改成功后，再将修改过的那个副本和原对象在一个不抛出异常的操作中置换（swap）。

对于copy and swap 策略来说，有两个重点

①copy

对原本的对象作出一份副本，在已经完成拷贝构造函数的前提下这是极为轻松的，也没什么可以多说的。

template <class Temp>    LinkList<Temp>::LinkList(const LinkList &copy)    {        LinkNode<Temp> *p = copy.Head->next;        try        {            Head = new LinkNode<Temp>;            LinkNode<Temp> *h = Head;            while (p != NULL)            {                LinkNode<Temp> *t = new LinkNode<Temp>;                h->next = t;                t->data = p->data;                p = p->next;                h = h->next;            }        }        catch (const bad_alloc & e)        {            cerr << "分配内存失败!" << endl;            exit(1);        }    }

此时我们只需要在赋值函数中调用拷贝构造函数即可完成copy操作

LinkList<Temp> temp(*this);

②swap

对于交换而言可以说的东西确实不少，应该提出一个不抛出异常的swap函数，具体的构造方法详见 Efficetive c++ 条款25.对于我们的单链表，具体的实现如下

    template<class Temp>    void LinkList<Temp>::swap(LinkList<Temp> & other)    {        using std::swap;        swap(Head, other.Head);    }    template<typename Temp>    void swap(LinkList<Temp> & a, LinkList<Temp> & b)    {        a.swap(b);    }

该专属swap与单链表类定义在同一个名称空间内。能够完成两个单链表对象的置换。

至此我们可以写成基于copy-and-swap的赋值函数

template <class Temp>    LinkList<Temp> &  LinkList<Temp>::operator=(LinkList<Temp> &List)    {        try        {            LinkList<Temp> temp(*this);            temp.DestoryList();            LinkNode<Temp> *p = List.Head;            LinkNode<Temp> *h = temp.Head;            while (p != NULL)            {                LinkNode<Temp> *t = new LinkNode<Temp>;                h->next = t;                t->data = p->data;                p = p->next;                h = h->next;            }            swap(temp);            return *this;        }        catch (const bad_alloc & e)        {            cerr << "error !" << endl;            return *this;        }    }

“强烈保证”往往都能够以copy-and-swap实现，但是“强烈保证”并非对所有函数都可以实现。但确实也是一个很有意义的策略！