异常安全的复制构造函数和拷贝赋值运算符函数

---

异常安全性问题

• 异常安全代码
  在出现异常的情况下仍然能够正确运行
• 异常中立
  将所有的异常都转发给调用者
• 永远不要在析构函数、重载运算符函数operator delete()或者operator delete[]中抛出异常
  在编写析构函数和内存释放函数时，要假设存在throw()这样的异常规范

以template < typename T > class Stack为例

template <typename T>class Stack{public:    Stack();    ~Stack();    Stack( const Stack & );    Stack & operator=( const Stack & );    size_t Count() const { return vused_; }    void Push( const T& t );    T & Top()    {        if ( 0 == vused_ )        {            throw "empty stack";        }        return v_[vused_-1];    }    void Pop()    {        if ( 0 == vused_ )        {            throw "pop from empty stack";        }        else        {            -- vused_;        }    }private:    T *NewCopy( const T *src,                size_t srcsize,                size_t destsize );    T * v_;    size_t vsize_;    size_t vused_;};

默认构造过程

template <typename T>Stack<T>::Stack()    : v_( new T[10] ),    vsize_( 10 ),    vused_( 0 ){}

析构过程

template <typename T>Stack<T>::~Stack(){    delete[] v_;}

辅助函数

template <typename T>T *Stack<T>::NewCopy( const T *src, size_t srcsize, size_t destsize ){    assert( destsize >= srcsize );    T *dest =   new T[destsize];    try    {        copy( src, src+srcsize, dest );    }    catch ( ... )    {        delete[] dest;        throw;    }    return dest;}

拷贝构造函数

template <typename T>Stack<T>::Stack( const Stack<T> &other )    : v_( NewCopy( other.v_, other.vsize_, other.vsize_ ) ),      vsize_( other.vsize_ ),      vused_( other.vused_ ){}

拷贝赋值过程

template <typename T>Stack<T> &Stack<T>::operator=( const Stack<T> &other ){    if ( this != &other )    {        T *v_new =  NewCopy( other.v_, other.vsize_, other.vsize_ );        delete[] v_;        v_ =    v_new;        vsize_ =    other.vsize_;        vused_ =    other.vused_;    }    return *this;}

Push()

template <typename T>void Stack<T>::Push( const T &t ){    if ( vused_ == vsize_ )    {        size vsize_new =    vsize_*2+1;        T *v_new =  NewCopy( v_, vsize_, vsize_ );        delete[] v_;        v_ =    v_new;        vsize_ =    vsize_new;    }    v_[vused_] =    t;    ++ vused_;}

• 基本保证：如果在类型T中或者程序中其他的地方抛出了异常，对象不应该造成资源泄漏
• 强保证：如果某个操作由于抛出异常而终止，那么程序的状态应该保持不变
• 无异常抛出保证：无论什么情况下，函数都不会抛出异常

封装内存管理工作

template <typename T1, typename T2>void construct( T1 *p, const T2 &value ){    new (p) T1(value);}template <typename T>void destroy( T *p ){    p->~T();}template <typename T>void destroy( T first, T last ){    while ( first != last )    {        destroy( &*first );        ++ first;    }}template <typename T>class StackImpl{protected:    StackImpl( size_t size=0 )        : v_( static_cast<T *>( 0==size ? 0 : operator new( sizeof(T)*size ) ) ),          vsize_( size ),          vused_( 0 )    {    }    ~StackImpl()    {        destroy( v_, v_+vused_ );        operator delete( v_ );    }    void Swap( StackImpl & other ) throw()    {        swap( v_, other.v_ );        swap( vsize_, other.vsize_ );        swap( vused_, other.vused_ );    }    T *v_;    size_t vsize_;    size_t vused_;private:    StackImpl( const StackImpl & );    StackImpl & operator=( const StackImpl & );};

更好的Stack

template <typename T>class Stack : private StackImpl<T>{public:    Stack( size_t size=0 )        : StackImpl<T>( size )    { }    ~Stack();    Stack( const Stack &other )        : StackImpl<T>( other.vused_ )    {        while ( vused_ < other.vused_ )        {            construct( v_+vused_, other.v_[vused_] );            ++ vused_;        }    }    Stack & operator=( const Stack & other )    {        Stack temp( other );        Swap( temp );        return *this;    }    size_t Count() const    {        return vused_;    }    void Push( const T & )    {        if ( vused_ == vsize_ )        {            Stack temp( vsize_*2+1 );            while ( temp.Count() < vused_ )            {                temp.Push( v_[temp.Count()] );            }            temp.Push( t );            swap( temp );        }        else        {            construct( v_+vused_, t );            ++ vused_;        }    }    T & Top()    {        if ( 0 == vused_ )        {            throw "empty stack";        }        return v_[ vused_-1 ];    }    void Pop()    {        if ( 0 == vused_ )        {            throw "pop from empty stack";        }        else        {            -- vused_;            destroy( v_+vused_ );        }    }}

优雅的实现

假设在StackImpl中，属性为public

template <typename T>class Stack{public:    Stack( size_t size=0 )        : impl( size )    { }    ~Stack();    Stack( const Stack & other )        : impl( other.impl_.vused_ )    {        while ( impl_.vused_ < other.impl_.vused_ )        {            construct( impl_.v_+impl_.vused_, other.impl_.v_[impl_.vused_] );            ++ impl_.vused_;        }    }    Stack & operator=( const Stack & other )    {        Stack temp( other );        impl_.Swap( other.impl_ );        return *this;    }    size_t Count() const    {        return impl_.vused_;    }    void Push( const T& t )    {        if ( impl_.vused_ == impl_.vsize_ )        {            Stack temp( impl_.vsize_*2+1 );            while ( temp.Count() < impl_.vused_ )            {                temp.Push( impl_.v_[temp.Count()] );            }            temp.Push( t );            impl_.Swap( temp.impl_ );        }        else        {            construct( impl_.v_+impl_.vused_, t );            ++ impl_.vused_;        }    }    T &Top()    {        if ( 0 == impl_.vused_ )        {            throw "empty stack";        }        returm impl_.v_[ impl_.vused_-1 ];    }    void Pop()    {        if ( 0 == impl_.vused_ )        {            throw "pop from empty stack";        }        else        {            --impl_.vused_;            destroy( impl_.v_+impl_.vused_ );        }    }private:    StackImpl< T > impl_;};

安全的异常

指导原则

• 永远不要在析构函数、重载的operator delete()或者operator delete[]()等函数中抛出异常：编写每个析构函数和内存释放函数时，都要假定在声明这些函数的时候使用了throw()异常规范
• 通过RAII(“资源获得也就意味着初始化”)这种惯用法来分离资源的所有权和资源的管理权
• 在每个函数中，将所有可能会抛出异常的代码放在一起，并进行安全处理，当确认这些代码所进行的工作都已经成功地完成时，才可以使用不会抛出异常的操作来修改程序的状态

---

参考资料：
《Exceptional C++中文版》