C++的营养
swap手法
??? swap手法不應當是C++獨有的技術(shù)，很多語言都可以實現(xiàn)，并且從中得到好處。只是C++存在的一些缺陷迫使大牛們發(fā)掘，并開始重視這種有用的手法。這 個原本被用來解決C++的資源安全和異常保證問題的技術(shù)在使用中逐步體現(xiàn)出越來越多的應用，有助于我們編寫更加簡潔、優(yōu)雅和高效的代碼。??? 接下來，我們先來和swap打個招呼。然后看看在C#里如何玩出swap。最后展示swap手法的幾種應用，從中我們將看到它是如何的可愛。
??? 假設(shè)，我要做一個類，實現(xiàn)統(tǒng)計并保存一個字符串中字母的出現(xiàn)次數(shù)，以及總的字母和數(shù)字的個數(shù)。
????????class?CountStr
????????{
????????public:
????????????explicit?CountStr(std::string?const&?val)
????????????????:m_str(val),?m_nLetter(0),?m_nNumber(0)?{
????????????????do_count(val);
????????????}
????????????CountStr(CountStr?const&?cs)
????????????????:m_str(cs.m_str),?m_counts(cs.m_counts)
????????????????,?m_nLetter(cs.m_nLetter),?m_nNumber(cs.m_nNumber)
????????????{}
???????????????void?swap(CountStr&?cs)?{
???????????????????std::swap(m_str,?cs.m_str);
???????????????????m_counts.swap(m_str);
???????????????????std::swap(m_nLetter,?cs.m_nLetter);
???????????????????std::swap(m_nNumber,?cs.m_nNumber);
???????????????}
????????private:
????????????std::string?m_str;
????????????std::map<char,?int>?m_counts;
????????????int?m_nLetter;
????????????int?m_nNumber;
????????} ??? 在類CountStr中，定義了swap成員函數(shù)。swap接受一個CountStr&類型的參數(shù)。在函數(shù)中，我們可以看到一組函數(shù)調(diào)用，每一個 對應一個數(shù)據(jù)成員，其任務是將相對應的數(shù)據(jù)成員的內(nèi)容相互交換。此處，我使用了兩種調(diào)用，一種是使用std::swap()標準函數(shù)，另一種是通過 swap成員函數(shù)執(zhí)行這個交換。一般情況下，std::swap()通過一個臨時變量實現(xiàn)對象的內(nèi)容交換。但對于string、map等非平凡的對象，這 種交換會引發(fā)至少三次深拷貝，其復雜度將是O(3n)的，性能極差。因此，標準庫為這些類定義了swap成員函數(shù)，通過成員函數(shù)可以實現(xiàn)O(1)的交換操 作。同時將std::swap()針對這些擁有swap()成員函數(shù)的標準容器特化，使其可以直接使用swap()成員函數(shù)，而避免性能損失。但是，對于 那些擁有swap()成員，但沒有被特化的用戶定義，或第三方的類，則不應使用std::swap()，而改用swap()成員函數(shù)。所以，一般情況下， 為了避免混淆，對于擁有swap()成員函數(shù)的類，調(diào)用swap()，否則調(diào)用標準std::swap()函數(shù)。
????順便提一下，在未來的C++0x中，由于引入了concept機制，可以允許一個函數(shù)模板自動識別出所有“具有swap()成員”的類型，并使用相應的特化版本。這樣便只需使用std::swap()，而不必考慮是什么樣的類型了。
??? 言歸正傳。這里，swap()成員函數(shù)有兩個要求，其一是復雜度為O(1)，其二是具備無拋擲的異常保證。前者對于性能而言至關(guān)重要，否則swap操作將 會由于性能問題而無法在實際項目中使用。對于后者，是確保強異常保證（commit or rollback語義）的基石。要達到這兩個要求，有幾個關(guān)鍵要點：首先，對于類型為內(nèi)置類型或小型POD（8～16字節(jié)以內(nèi)）的成員數(shù)據(jù)，可以直接使用 std::swap()；其次，對于非平凡的類型（擁有資源引用，復制構(gòu)造和賦值操作會引發(fā)深拷貝），并且擁有符合上述要求的swap()成員函數(shù)的，直 接使用swap()成員函數(shù)；最后，其余的類型，則保有其指針，或智能指針，以確保滿足上述兩個要求。
??? 聽上去有些復雜，但在實際開發(fā)中做到并不難。首先，盡量使用標準庫容器，因為標準庫容器都擁有滿足兩個條件的swap()成員。其次，在編寫的每一個類中 實現(xiàn)滿足兩個條件的swap()成員。最后，對于那些不具備swap()成員函數(shù)的第三方類型，則使用指針，最好是智能指針。（也就是Sutter所謂的 PImpl手法）。只要堅持這些方針，必能收到很好的效果。
??? 下面，就來看一下這個swap()的第一個妙用。假設(shè)，這個類需要復制。通常可以通過operator=操作符，或者copy（或其他有明確的復制含義 的）成員函數(shù)實現(xiàn)，這兩者實際上是等價的，只是形式不同而已。這里選擇operator=，因為它比較C++:)。
??? 最直白的實現(xiàn)方式是這樣：
????????class?CountStr
????????{
????????public:
????????????...
????????????CountStr&?operator=(CountStr&?val)?{
????????????????m_str=val.m_str;
????????????????m_counts=val.m_counts;
????????????????m_nLetter=val.m_nLetter;
????????????????m_nNumber=val.m_nNumber;
????????????}
????????????...
????????} ??? 很簡單，但是不安全，或者說沒有滿足異常保證。
??? 先解釋一下異常保證。異常保證有三個級別：基本保證、強異常保證和無拋擲保證?；颈ＷC是指異常拋出時，程序的各個部分應當處于有效狀態(tài)，不能有資源泄 漏。這個級別可以輕而易舉地利用RAII確保，這在前一篇已經(jīng)展示過了。強異常保證則更加嚴格，要求異常拋出后，程序非但要滿足基本保證，其各個部分的數(shù) 據(jù)應保持原狀。也就是要滿足“Commit or Rollback”語義，熟悉數(shù)據(jù)庫的人，可以聯(lián)想一下Transaction的行為。而無拋擲保證要求函數(shù)在任何情況下都不會拋出異常。無拋擲保證不是 說用一個catch(...)或throw()把異常統(tǒng)統(tǒng)吞掉。而是說在無拋擲保證的函數(shù)中的任何操作，都不會拋出異常。能滿足無拋擲保證的操作還是很多 的，比如內(nèi)置POD類型（int、指針等等）的復制，swap手法便以此為基礎(chǔ)。（多說一句，用catch(...)吞掉異常來確保無拋擲并非絕對不行， 在特定情況下，還是可以偶爾一用。不過這等爛事也只能在西構(gòu)函數(shù)中進行，而且也只有在迫不得已的情況下用那么一下）。
????如果這四個賦值操作 中，任意一個拋出異常，便會退出這個函數(shù)（操作符）。此時，至少有一個成員數(shù)據(jù)沒有正確修改，而其他的則全部或部分地發(fā)生改變。于是，一部分成員數(shù)據(jù)是新 的，另一部分是舊的，甚至還有一些是不完全的。這在軟件中往往會引發(fā)很多令人苦惱的bug。無論如何，此時應當運用強異常保證，使得數(shù)據(jù)要么是新的值，要 么沒有改變。那么如何獲得強異常保證？在swap()的幫助下，驚人的簡單：
????????class?CountStr
????????{
????????public:
????????????...
????????????CountStr&?operator=(CountStr&?val)?{
????????????????swap(CountStr(val));?//?或者CountStr(val).swap(*this);
????????????????raturn?*this;????????????????????
????????????}
????????????...
????????} ??? 我想世上沒有比這等代碼更加漂亮的了吧！不僅僅具有簡潔動人的外表，而且充滿了豐富的內(nèi)涵。這就叫優(yōu)雅。不過，優(yōu)雅之下還需要一些解釋。在這兩個版本中， 都是先用復制構(gòu)造創(chuàng)建一個臨時對象，這個臨時對象同傳入的參數(shù)對象擁有相同的值。然后用swap()成員函數(shù)將this對象的內(nèi)容與臨時對象交換。于是， this對象擁有了臨時對象的值，也就是與傳入的實參對象具有相同的值（復制）。當退出函數(shù)的時候，臨時對象銷毀，自然而然地釋放了this對象原先的資 源（前提是CountStr類實現(xiàn)了RAII）。
??? 那么拋出異常的情況又是怎樣的呢？
??? 先來看看operator=里執(zhí)行了哪些步驟，并考察這些步驟的異常拋擲的情況。如果將代碼改寫成另一個等價的形式，就很容易理解了：
????????????CountStr&?operator=(CountStr&?val)?{
????????????????CountStr?t_(val);????//此處可能拋出異常，但只有t_的值發(fā)生變化
????????????????t_.swap(*this);???????//由于swap擁有無拋擲保證，所以不會拋出異常
????????????????return?*this；
????????????} ??? 在構(gòu)造臨時對象的時候，可能會拋出異常，因為此時執(zhí)行了數(shù)據(jù)的復制和構(gòu)造。請注意，這時候this對象的內(nèi)容沒有改變。如果此時拋出異常，數(shù)據(jù)發(fā)生改變的 只有t_，this對象并未受到影響。而隨著棧清理，t_也將被析構(gòu)，在RAII的作用下，t_所占用的資源也會依次釋放。而下一步，swap()成員的 調(diào)用，則是無拋擲保證的，不會拋出異常，this的內(nèi)容可以得到充分地、原子地交換，不會發(fā)生數(shù)據(jù)值修改一半的情況。
??? 在C#中，實現(xiàn)swap非常容易，甚至比C++更容易。因為在C#中，大部分對象都在堆上，代碼中定義的所謂對象實際上是引用。對于引用的賦值操作是無拋擲的，因此在C#中可以采用同C++幾乎一樣的代碼實現(xiàn)swap：
????????class?CountStr
????????{
????????????public?CountStr(string?val)?{
????????????????m_str=val;
????????????????m_nLetter=0;
????????????????m_nNumber=0;
????????????????do_count(val);
????????????}
????????????public?CountStr(CountStr?cs)?{
????????????????m_str=new?string(cs.m_str);
????????????????m_counts=new?Dictionary<char,?int>(cs.m_counts);
????????????????m_nLetter=cs.m_nLetter;
????????????????m_nNumber=cs.m_nNumber
????????????}
??????????????public?void?swap(CountStr&?cs)?{
???????????????????utility.swap(ref?m_str,?ref?cs.m_str);
???????????????????utility.swap(ref?m_counts,?ref?cs.m_counts);
???????????????????utility.swap(ref?m_nLetter,?ref?cs.m_nLetter);
???????????????????utility.swap(ref?m_nNumber,?ref?cs.m_nNumber);
??????????????}
????????????public?void?copy(CountStr&?cs)?{
????????????????this.swap(new?CountStr(cs));
????????????}
????????????private?string?m_str;
????????????private?Dictionary<char,?int>?m_counts;
????????????private?int?m_nLetter;
????????????private?int?m_nNumber;
????????} ??? 這里utility.swap()是一個泛型函數(shù)，作用是交換兩個參數(shù)：
????????class?utility
????????{
????????????public?static?void?swap<T>(ref?T?lhs,?ref?T?rhs)?{
????????????????T?t_=lhs;
????????????????lhs=rhs;
????????????????rhs=t_;
????????????}
????????} ??? 如果類有關(guān)鍵性的資源需要釋放，那么可以實現(xiàn)IDisposable接口，然后在copy()中使用using：
????????????public?void?copy(CountStr&?cs)?{
????????????????using(CountStr?t_=new?CountStr(cs))
????????????????????{
????????????????????????t_.swap(this);
????????????????????}
????????????} ??? 如此，對象原有的數(shù)據(jù)和資源被交換到臨時對象t_中之后，在退出using作用域的時候，會立即得到釋放。這是RAII的一個應用，詳細內(nèi)容參見本系列的前一篇《C++的營養(yǎng)——RAII》。
??? swap的基本作用是維持強異常保證語義。但是，作為一種基礎(chǔ)性的技術(shù)，它還可以擁有更多的用途。下面介紹幾種主要的應用，為了節(jié)省篇幅，案例直接使用C#，不再給出C++的代碼。
??? 在我們的開發(fā)過程中，有時需要是一些對象復位，即回復對象的初始狀態(tài)。一般情況下，我們會在類中增加一個reset()之類的成員，在這個函數(shù)中釋放資源，恢復各成員數(shù)據(jù)的初值。但是，在擁有swap的情況下，這種操作變得非常容易：
????????class?X
????????{
????????????public?X()?{
????????????????...?//初始化對象
????????????}
????????????public?X(int?v)?{
????????????????...?//以v初始化對象
????????????}
????????????public?void?swap(X?val)?{...}
????????????public?void?reset()?{
????????????????this.swap(new?X());
????????????}
????????????...
????????} ??? reset()用X的默認構(gòu)造函數(shù)創(chuàng)建了一個臨時對象，將其內(nèi)容與this交換，this的內(nèi)容便成為了初始值。重要的是，這個成員函數(shù)也是 強異常保證 的。如果需要通過一些參數(shù)復位，那么同樣可以做到：
????????class?X
????????{
????????????...
????????????public?void?reset(int?v)?{
????????????????this.swap(new?X(v));
????????????}
????????????...
????????} ??? 有時甚至可以不需要reset這個成員，而直接在代碼中使用swap復位一個對象：
????????X?x=new?X();
????????...?//對x的操作，改變了內(nèi)容
????????x.swap(new?X());?//復位了 ??? 如果X有資源需要釋放，那么只需實現(xiàn)IDispose，然后使用using：
????????class?X?:?IDisposable
????????{
????????????...
????????????public?void?reset()?{
????????????????using(X?t=new?X())
????????????????{
????????????????????this.swap(t);
????????????????}
????????????}
????????????public?void?Dispose()?{...}
????????????...
????????} ??? 上面這些應用都有一個共同點，即重新初始化一個對象，使其恢復到一個初始狀態(tài)。下面的應用，則反其道而行之，將一個對象切換到另一個狀態(tài)。
??? 有時，我們會做一些類，在構(gòu)造函數(shù)中執(zhí)行一些復雜的操作，比如解析一個文本文件，然后向外公布解析后的結(jié)果。之后，我們需要在這個對象上load另一個文 件，那么通常都寫一個load成員函數(shù)，先釋放掉原先占用的資源，然后再加載新的文件。如果有了swap，那么這個load函數(shù)同樣極其簡單：
????????class?Y?:?IDisposable
????????{
????????????public?Y(string?filename)?{
????????????????...?//打開文件，執(zhí)行解析
????????????}
????????????public?void?swap(Y?val)?{...}
????????????public?load(string?filename)?{
????????????????using(Y?t=new?Y(filename))
????????????????{
????????????????????this.swap(t);
????????????????}
????????????}
????????????public?void?Dispose()?{
????????????????...?//關(guān)閉文件，釋放資源
????????????}
????????} ??? 還有一種情況，有一些類，通過一些數(shù)據(jù)創(chuàng)建，創(chuàng)建之后在絕大多數(shù)的情況下都是只讀的，但偶爾會需要改變其內(nèi)部數(shù)據(jù)。為了代碼的可靠性，我們可以把類寫成只讀的。但是如何修改其內(nèi)部的數(shù)據(jù)呢？也可以通過swap：
????????class?Z
????????{
????????????public?Z(int?a,?float?b)?{
????????????????m_a=a;
????????????????m_b=b;
????????????}
????????????public?void?swap(Z?val)?{...}
????????????public?int?a?{?get{return?m_a;}}
????????????public?float?b?{?get{return?m_b;}}
????????????private?int?m_a;
????????????private?float?m_b;
????????}
????????Z?z=new?Z(3,?4.5);
????????z.swap(new?Z(5,?5.4));?//z的值已修改 ??? 這樣便可避免對Z的實例的隨意修改。但是，這種修改方式會造成性能損失，特別是數(shù)據(jù)成員存在非O(1)復制的情況下（如有字符串、數(shù)組等），只有在修改偶爾發(fā)生的情況下才能使用。
??? 有些類，構(gòu)造函數(shù)需要一些數(shù)據(jù)初始化對象，并且會創(chuàng)建的過程中會驗證其有效性，和執(zhí)行一些計算。也就是構(gòu)造函數(shù)存在一定的數(shù)據(jù)邏輯。如果需要修改對象的某 些值，會牽涉到相應的復雜數(shù)據(jù)邏輯。通常都是把這些邏輯獨立在private成員函數(shù)中，由構(gòu)造函數(shù)和數(shù)據(jù)修改操作共享。這樣的做法往往不能帶來強異常保 證，在構(gòu)造函數(shù)里的數(shù)據(jù)驗證往往會拋出異常。因此，如果使用swap，便可以消除這類問題，并且使代碼簡化：
????????class?A
????????{
????????????public?A(int?a,?string?b,?Rectangle?c)?{
????????????????...?//數(shù)據(jù)邏輯、計算等
????????????}
????????????public?int?a?{
????????????????set{?this.swap(new?A(value,?m_b,?m_c));}
????????????}
????????????public?string?b?{
????????????????set{?this.swap(new?A(m_a,?value,?m_c));}
????????????}
????????????public?Rectangle?c?{
????????????????set{?this.swap(new?A(m_a,?m_b,?value));}
????????????}
????????????...
???????} ??? 當然，也可以在類外直接進行這樣的數(shù)據(jù)設(shè)置：
????????A?a=new?A(2,?"zzz",?Rectangle(1,1,?10,10));
????????a.swap(new?A(3,?"zzz",?Rectangle(1,1,?10,10))); ??? 這種用法可以用于某些只保存對構(gòu)造函數(shù)參數(shù)的計算結(jié)果，而不需要保存這些參數(shù)的類（m_a，m_b，m_c都不需要了），只是使用上過于瑣碎。
??? 所有這些與對象狀態(tài)設(shè)置有關(guān)的swap用法，都集中表現(xiàn)了一個特性，即使得我們可以將對象的初始化代碼集中在構(gòu)造函數(shù)中，數(shù)據(jù)和資源清理的代碼集中在 Dispose()中。這種做法可以大大提高代碼的可維護性。如果一個軟件項目中，每個類都實現(xiàn)swap和復制構(gòu)造函數(shù)（除非該類不允許復制），并盡可能 集中數(shù)據(jù)邏輯代碼，那么會使得代碼質(zhì)量有答復的提高。
??? 在上一篇《C++的營養(yǎng)——RAII》中，我提到守衛(wèi)一個結(jié)構(gòu)復雜的類：在代碼中修改一個對象，然后再回復原來的狀態(tài)。如果單純手工地保存對象數(shù)據(jù)，通常 很困難（有時甚至是不可能的），而且也難以維持異常安全性（強異常保證）。但是如果使用了swap，那么將會易如反掌：
????????void?ScopeObject(MyCls?obj)?{
????????????using(MyCls?t_=new?MyCls(obj))
????????????{
????????????????...?//操作obj，改變其狀態(tài)或數(shù)據(jù)
????????????????obj.swap(t_);?//恢復原來的狀態(tài)
????????????}
????????} ??? 當然，也可以直接使用t_執(zhí)行操作，這就不需要執(zhí)行swap。在一般情況下兩者是等價的。但是，在某些特殊情況下，比如類持有特殊資源，或者obj是并發(fā) 中的共享對象的時候，兩種方法有可能不等價。swap方案使用上更全面些。總的來說相差不多，放在這里僅供參考。
??? 作為更進一步的發(fā)展，可以構(gòu)造一個ISwapable泛型接口：
????????interface?ISwapable<T>
????????{
????????????void?swap(T?v);
????????} ??? 對于需要實現(xiàn)swap手法的類，實現(xiàn)這個接口：
????????class?B?:?ISwapable<B>
????????{
????????????public?B()?{...}
????????????public?void?swap(B?v)?{...}
????????????...
????????} ??? 這將會帶來一個好處，通過泛型算法實現(xiàn)某些特定的操作：
????????class?utility
????????{
????????????public?static?void?reset<T>(T?obj)
????????????????where?T?:?ISwapable
????????????????where?T?:?new()
????????????{
????????????????obj.swap(new?T());
????????????}
????????} ??? 這樣便無須為每一個類編寫reset成員函數(shù)，只需這一個泛型算法即可：
????????X?x;
????????Y?y;
????????utility.reset(x);
????????utility.reset(y);
????????... ??? swap手法可能在存在其他諸多應用，在編碼的時候可以不斷地發(fā)掘。只需要抓住一個原則：swap可以無拋擲，簡潔地修改一個對象的值。swap所帶來的 一個問題主要是性能方面。swap通常伴隨著臨時對象的構(gòu)造，多數(shù)情況下，這種構(gòu)造不會引發(fā)更多的性能損失，但在某些數(shù)據(jù)修改的應用中，會比直接的數(shù)據(jù)修 改損失更多的性能。如何取舍，需要根據(jù)具體情況分析和權(quán)衡。總的來說，swap手法所帶來的好處是顯而易見的，特別是強異常保證，往往是至關(guān)重要的。而諸 如簡化代碼等的作用，則無需多言，一用便知。
??? 或許swap手法非常基礎(chǔ)，非常細小，而且很多人不用swap也過來了。但是，聚沙成塔，每一處細小的優(yōu)化，積累起來則是巨大的進步。還是劉皇叔說得好：“勿以善小而不為，勿以惡小而為之”。?
總結(jié)
- 上一篇： Linux下nm和ldd 命令
- 下一篇： c++异常处理机制示例及讲解