前腐后继 发表于 2006-12-31 12:40:00

如何编写异常安全的C++代码,分享成功,多提宝贵见解

<p>作者:yanglilibaobao</p><p>关于C++中异常的争论何其多也,但往往是一些不合事实的误解。异常曾经是一个难以用好的语言特性,幸运的是,随着C++社区经验的积累,今天我们已经有足够的知识轻松编写异常安全的代码了,而且编写异常安全的代码一般也不会对性能造成影响。</p><p>  使用异常还是返回错误码?这是个争论不休的话题。大家一定听说过这样的说法:只有在真正异常的时候,才使用异常。那什么是“真正异常的时候”?在回答这个问题以前,让我们先看一看程序设计中的不变式原理。 <br/> 对象就是属性聚合加方法,如何判定一个对象的属性聚合是不是处于逻辑上正确的状态呢?这可以通过一系列的断言,最后下一个结论说:这个对象的属性聚合逻辑上是正确的或者是有问题的。这些断言就是衡量对象属性聚合对错的不变式。</p><p> 我们通常在函数调用中,实施不变式的检查。不变式分为三类:前条件,后条件和不变式。前条件是指在函数调用之前,必须满足的逻辑条件,后条件是函数调用后必须满足的逻辑条件,不变式则是整个函数执行中都必须满足的条件。在我们的讨论中,不变式既是前条件又是后条件。前条件是必须满足的,如果不满足,那就是程序逻辑错误,后条件则不一定。现在,我们可以用不变式来严格定义异常状况了:满足前条件,但是无法满足后条件,即为异常状况。当且仅当发生异常状况时,才抛出异常。</p><p> 关于何时抛出异常的回答中,并不排斥返回值报告错误,而且这两者是正交的。然而,从我们经验上来说,完全可以在这两者中加以选择,这又是为什么呢?事实上,当我们做出这种选择时,必然意味着接口语意的改变,在不改变接口的情况下,其实是无法选择的(试试看,用返回值处理构造函数中的错误)。通过不变式区别出正常和异常状况,还可以更好地提炼接口。</p><p> 对于异常安全的评定,可分为三个级别:基本保证、强保证和不会失败。</p><p> 基本保证:确保出现异常时程序(对象)处于未知但有效的状态。所谓有效,即对象的不变式检查全部通过。<br/>  强保证:确保操作的事务性,要么成功,程序处于目标状态,要么不发生改变。<br/>  不会失败:对于大多数函数来说,这是很难保证的。对于C++程序,至少析构函数、释放函数和swap函数要确保不会失败,这是编写异常安全代码的基础。</p><p> 首先从异常情况下资源管理的问题开始.很多人可能都这么干过:</p><p>Type* obj = new Type;<br/>try{ do_something...}<br/>catch(...){ delete obj; throw;} </p><p>  不要这么做!这么做只会使你的代码看上去混乱,而且会降低效率,这也是一直以来异常名声不大好的原因之一. 请借助于RAII技术来完成这样的工作: <br/>  auto_ptr&lt;Type&gt; obj_ptr(new Type);<br/>do_something... </p><p>  这样的代码简洁、安全而且无损于效率。当你不关心或是无法处理异常时,请不要试图捕获它。并非使用try...catch才能编写异常安全的代码,大部分异常安全的代码都不需要try...catch。我承认,现实世界并非总是如上述的例子那样简单,但是这个例子确实可以代表很多异常安全代码的做法。在这个例子中,boost::scoped_ptr是auto_ptr一个更适合的替代品。 <br/> 现在来考虑这样一个构造函数:</p><p>Type() : m_a(new TypeA), m_b(new TypeB){} </p><p>  假设成员变量m_a和m_b是原始的指针类型,并且和Type内的申明顺序一致。这样的代码是不安全的,它存在资源泄漏问题,构造函数的失败回滚机制无法应对这样的问题。如果new TypeB抛出异常,new TypeA返回的资源是得不到释放机会的.曾经,很多人用这样的方法避免异常:<br/>Type() : m_a(NULL), m_b(NULL){<br/>auto_ptr&lt;TypeA&gt; tmp_a(new TypeA);<br/>auto_ptr&lt;TypeB&gt; tmp_b(new TypeB);<br/>m_a = tmp_a.release();<br/>m_b = tmp_b.release();<br/>} </p><p>  当然,这样的方法确实是能够实现异常安全的代码的,而且其中实现思想将是非常重要的,在如何实现强保证的异常安全代码中会采用这种思想.然而这种做法不够彻底,至少析构函数还是要手动完成的。我们仍然可以借助RAII技术,把这件事做得更为彻底:shared_ptr&lt;TypeA&gt; m_a; shared_ptr&lt;TypeB&gt; m_b;这样,我们就可以轻而易举地写出异常安全的代码:</p><p>Type() : m_a(new TypeA), m_b(new TypeB){} </p><p> 如果你觉得shared_ptr的性能不能满足要求,可以编写一个接口类似scoped_ptr的智能指针类,在析构函数中释放资源即可。如果类设计成不可复制的,也可以直接用scoped_ptr。强烈建议不要把auto_ptr作为数据成员使用,scoped_ptr虽然名字不大好,但是至少很安全而且不会导致混乱。</p><p> RAII技术并不仅仅用于上述例子中,所有必须成对出现的操作都可以通过这一技术完成而不必try...catch.下面的代码也是常见的:</p><p>a_lock.lock(); <br/>try{ ...} catch(...) {a_lock.unlock();throw;}<br/>a_lock.unlock();&nbsp; </p><p> 可以这样解决,先提供一个成对操作的辅助类:</p><p>struct scoped_lock{<br/>explicit scoped_lock(Lock&amp; lock) : m_l(lock){m_l.lock();}<br/>~scoped_lock(){m_l.unlock();}<br/>private: <br/>Lock&amp; m_l;<br/>}; </p><p> 然后,代码只需这样写:</p><p>scoped_lock guard(a_lock);<br/>do_something... </p><p> 清晰而优雅!继续考察这个例子,假设我们并不需要成对操作, 显然,修改scoped_lock构造函数即可解决问题。然而,往往方法名称和参数也不是那么固定的,怎么办?可以借助这样一个辅助类:</p><p>template&lt;typename FEnd, typename FBegin&gt;<br/>struct pair_guard{<br/>pair_guard(FEnd fe, FBegin fb) : m_fe(fe) {if (fb) fb();}<br/>~pair_guard(){m_fe();}<br/>private:<br/>FEnd m_fe;<br/>...//禁止复制<br/>};<br/>typedef pair_guard&lt;function&lt;void () &gt; , function&lt;void()&gt; &gt; simple_pair_guard; </p><p> 好了,借助boost库,我们可以这样来编写代码了:</p><p>simple_pair_guard guard(bind(&amp;Lock::unlock, a_lock), bind(&amp;Lock::lock, a_lock) );<br/>do_something... </p>

前腐后继 发表于 2006-12-31 12:40:00

<p>不得不承认,这样的代码不如前面的简洁和容易理解,但是它更灵活,无论函数名称是什么,都可以拿来结对。我们可以加强对bind的运用,结合占位符和reference_wrapper,就可以处理函数参数、动态绑定变量。所有我们在catch内外的相同工作,交给pair_guard去完成即可。</p><p> 考察前面的几个例子,也许你已经发现了,所谓异常安全的代码,竟然就是如何避免try...catch的代码,这和直觉似乎是违背的。有些时候,事情就是如此违背直觉。异常是无处不在的,当你不需要关心异常或者无法处理异常的时候,就应该避免捕获异常。除非你打算捕获所有异常,否则,请务必把未处理的异常再次抛出。try...catch的方式固然能够写出异常安全的代码,但是那样的代码无论是清晰性和效率都是难以忍受的,而这正是很多人抨击C++异常的理由。在C++的世界,就应该按照C++的法则来行事。</p><p> 如果按照上述的原则行事,能够实现基本保证了吗?诚恳地说,基础设施有了,但技巧上还不够,让我们继续分析不够的部分。</p><p> 对于一个方法常规的执行过程,我们在方法内部可能需要多次修改对象状态,在方法执行的中途,对象是可能处于非法状态的(非法状态 != 未知状态),如果此时发生异常,对象将变得无效。利用前述的手段,在pair_guard的析构中修复对象是可行的,但缺乏效率,代码将变得复杂。最好的办法是......是避免这么作,这么说有点不厚道,但并非毫无道理。当对象处于非法状态时,意味着此时此刻对象不能安全重入、不能共享。现实一点的做法是:</p><p> a.每一次修改对象,都确保对象处于合法状态<br/>   b.或者当对象处于非法状态时,所有操作决不会失败。</p><p> 在接下来的强保证的讨论中细述如何做到这两点。</p><p> 强保证是事务性的,这个事务性和数据库的事务性有区别,也有共通性。实现强保证的原则做法是:在可能失败的过程中计算出对象的目标状态,但是不修改对象,在决不失败的过程中,把对象替换到目标状态。考察一个不安全的字符串赋值方法:</p><p>string&amp; operator=(const string&amp; rsh){<br/>if (this != &amp;rsh){<br/>myalloc locked_pool(m_data);<br/>locked_pool.deallocate(m_data);<br/>if (rsh.empty())<br/>m_data = NULL;<br/>else{<br/>m_data = locked_pool.allocate(rsh.size() + 1);<br/>never_failed_copy(m_data, rsh.m_data, rsh.size() + 1);<br/>}<br/>}<br/>return *this;<br/>} </p><p> locked_pool是为了锁定内存页。为了讨论的简单起见,我们假设只有locked_pool构造函数和allocate是可能抛出异常的,那么这段代码连基本保证也没有做到。若allocate失败,则m_data取值将是非法的。参考上面的b条目,我们可以这样修改代码:</p><p>myalloc locked_pool(m_data);<br/>locked_pool.deallocate(m_data); //进入非法状态<br/>m_data = NULL; //立刻再次回到合法状态,且不会失败<br/>if(!rsh.empty()){<br/>m_data = locked_pool.allocate(rsh.size() + 1);<br/>never_failed_memcopy(m_data, rsh.m_data, rsh.size() + 1);<br/>} </p><p> 现在,如果locked_pool失败,对象不发生改变。如果allocate失败,对象是一个空字符串,这既不是初始状态,也不是我们预期的目标状态,但它是一个合法状态。我们阐明了实现基本保证所需要的技巧部分,结合前述的基础设施(RAII的运用),完全可以实现基本保证了...哦,其实还是有一点疏漏,不过,那就留到最后吧。</p><p> 继续,让上面的代码实现强保证:</p><p>myalloc locked_pool(m_data);<br/>char* tmp = NULL;<br/>if(!rsh.empty()){<br/>tmp = locked_pool.allocate(rsh.size() + 1); <br/>never_failed_memcopy(tmp, rsh.m_data, rsh.size() + 1); //先生成目标状态<br/>}<br/>swap(tmp, m_data); //对象安全进入目标状态<br/>m_alloc.deallocate(tmp); //释放原有资源 </p><p> 强保证的代码多使用了一个局部变量tmp,先计算出目标状态放在tmp中,然后在安全进入目标状态,这个过程我们并没有损失什么东西(代码清晰性,性能等等)。看上去,实现强保证并不比基本保证困难多少,一般而言,也确实如此。不过,别太自信,举一种典型的很难实现强保证的例子,对于区间操作的强保证:</p><p>for (itr = range.begin(); itr != range.end(); ++itr){<br/>itr-&gt;do_something();<br/>} </p><p> 如果某个do_something失败了,range将处于什么状态?这段代码仍然做到了基本保证,但不是强保证的,根据实现强保证的基本原则,我们可以这么做:</p><p>tmp = range;<br/>for (itr = tmp.begin(); itr != tmp.end(); ++itr){<br/>itr-&gt;do_something();<br/>}<br/>swap(tmp, range); </p><p> 似乎很简单啊!呵呵,这样的做法并非不可取,只是有时候行不通。因为我们额外付出了性能的代价,而且,这个代价可能很大。无论如何,我们阐述了实现强保证的方法,怎么取舍则由您决定了。</p><p> 接下来讨论最后一种异常安全保证:不会失败。</p><p> 通常,我们并不需要这么强的安全保证,但是我们至少必须保证三类过程不会失败:析构函数,释放类函数,swap。析构和释放函数不会失败,这是RAII技术有效的基石,swap不会失败,是为了“在决不失败的过程中,把对象替换到目标状态”。我们前面的所有讨论都是建立在这三类过程不会失败的基础上的,在这里,弥补了上面的那个疏漏。</p><p> 一般而言,语言内部类型的赋值、取地址等运算是不会发生异常的,上述三类过程逻辑上也是不会发生异常的。内部运算中,除法运算可能抛出异常。但是地址访问错通常是一种错误,而不是异常,我们本应该在前条件检查中就发现的这一点的。所有不会发生异常操作的简单累加,仍然不会导致异常。</p><p>  好了,现在我们可以总结一下编写异常安全代码的几条准则了:</p><p> 1.只在应该使用异常的地方抛出异常<br/>   2.如果不知道如何处理异常,请不要捕获(截留)异常。<br/>   3.充分使用RAII,旁路异常。<br/>   4.努力实现强保证,至少实现基本保证。<br/>   5.确保析构函数、释放类函数和swap不会失败。</p><p> 另外,还有一些语言细节问题,因为和这个主题有关也一并列出:</p><p> &nbsp;&nbsp; 1.不要这样抛出异常:throw new exception;这将导致内存泄漏。<br/>   2.自定义类型,应该捕获异常的引用类型:catch(exception&amp; e)或catch(const exception&amp; e)。<br/>   3.不要使用异常规范,即使是空异常规范。编译器并不保证只抛出异常规范允许的异常,更多内容请参考相关书籍。</p>
页: [1]
查看完整版本: 如何编写异常安全的C++代码,分享成功,多提宝贵见解