异常安全性问题
- 异常安全代码
在出现异常的情况下仍然能够正确运行- 异常中立
将所有的异常都转发给调用者- 永远不要在析构函数、重载运算符函数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++中文版》
网友评论