只在多態基類中聲明虛析構函數

關于virtual desctructor的詳細討論。同樣來自于《Effective C++》3rd Edition。

---

跟蹤時間是很平常的任務，所以開發一個名為 TimeKeeper 的基類，并讓不同的派生類來實現不同的計時方法是很合理的事情：

class TimeKeeper {

public :

??? TimeKeeper();

??? ~TimeKeeper();

??? ...

};

?

class AtomicClock: public TimeKeeper { ... };

class WaterClock: public TimeKeeper { ... };

class WristWatch: public TimeKeeper{ ... };

很多用戶都希望直接用這些類來計數，而對于他們究竟是如何實現的并不關心。于是一個我們可以用一個 Factory function ——創建一個派生類對象并返回一個基類指針的函數——返回一個指向 TimeKeeper 的指針。

TimeKeeper* getTimeKeeper(); // returns a pointer to a dynamically

???????????????????????? ? ??? // allocated object of a class derived

???????????????????????? ? ??? // from TimeKeeper

通常， factory function 返回的對象都是創建在堆上的，當用戶使用完計數器的時候把對象析構掉是很重要的：

TimeKeeper *ptk = getTimeKeeper(); // get dynamically allocated object

??????????????????????????? ?? ????? // from TimeKeeper hierarchy

...???????????????????????? ?? ?????// use it

delete ptk;???????????????????? ?? // release it to avoid resource leak

但是，依賴用戶來執行刪除是錯誤的重要來源。條款 18 介紹了如何修改 Factory function 的接口來避免這些常見的用戶錯誤，但是，這些目前都是次要的，因為在上面的代碼中還存在更為嚴重的問題：即使客戶執行的正確的動作，你還是無法預期你的程序能夠正確執行。

問題在于 getTimeKeeper 返回了一個派生類對象（例如 :AutoicClock ），但是這個對象卻通過基類的指針來刪除（一個指向 Timekeeper 的指針），并且這個基類沒有虛析構函數。這種組合是制造災難的良方，因為 C++ 規定：用不帶有虛析構函數的基類的指針來刪除一個派生類，其結果是未定的。通常在運行時發生的情況是這個對象的派生類部分沒有被析構。如果 getTimeKeeper 返回一個指向 AtomicClock 對象的指針，那么 AtomicClock 中派生類的部分（例如在 AtomicClock 中聲明的數據成員）將不會被正確的析構，實際上 AtomicClock 的析構函數都根本不會被調用。但是，基類的部分，卻會被正確的清除，這就造就了一個“畸形”的 partially destroyed object 。這是一個非常棒的泄漏資源、破壞數據的方法，它會讓你在調試器上花費大量的精力。

解決這個問題的方法很簡單，給派生類加上一個虛析構函數。這樣派生類對象就會如你所愿，被正確的清除：

class TimeKeeper {

public :

??? TimeKeeper();

??? virtual ~TimeKeeper();

??? ...

};

?

TimeKeeper *ptk = getTimeKeeper();

...???????????????????????????
delete ptk;???????????????? // now behaves correctlhy

像 TimeKeeper 這樣的基類，除了析構函數外，通常會包含其它的虛函數。因為虛函數的目標就是讓派生類來訂制基類的實現。例如， getCurrentTime ，在不同的派生類中就會有不同的實現（注：其實 getTimeKeeper 也可以是一個虛函數）。任何一個擁有虛函數的類都應該包含一個虛析構函數。

如果一個類沒有虛函數呢，這也就意味著這個類并不是被當作基類來使用的。當遇到這種情況的時候，聲明一個虛析構函數往往不是一個好主意。考慮一個用來表示二維空間中的某點的類：

class Point {// a 2D point

public :

??? Point(int xCoord, int yCoord);

??? ~Point();

?

private :

??? int x, y;
};

如果一個 int 占 32 bits ，這樣的一個 Point 可以被放到一個 64 位寄存器中。另外，這樣的一個 Point 對象還可以被當作是一個整體被其它的語言使用，例如 C 或 FORTRAN 。但是，如果 Point 的析構函數是虛擬的，故事就完全不一樣了。

虛函數的實現需要對象承載某些額外信息，這些信息用來在運行時對虛函數的調用進行正確的轉發。這個額外的信息使通過一個 vtpr 來實現的。 Vptr 指向一個存放函數指針（ vtbl ）的數組，每一個具有虛函數的類都有一個對應的 vtbl 。當一個對象的虛函數被調用的時候，該對象的 vtpr 和 vtbl 組合來完成定位正確的函數調用的工作。

這里，虛函數如何實現的并不重要。重要的是如果 Point 包含了一個虛函數，對象將會長胖。在一個 32 bits 的機器上，它將會從 64 bits 長到 96 bits ；在 64 bit 的機器上，它將會從 64 bits 長到 128 bits 。這個額外的 vtpr 的存在讓對象的體積增長了 50%~100% 。 Point 對象也不再能夠放到一個 64-bit 寄存器中了。另外， Point 對象也不再和 C 語言的保持兼容，因為 C 語言中沒有 vrpr 機制。結果是，你要想使用該 Point 對象，除非自己來實現 vtpr 和 vtpl 機制，而這樣做，往往又會降低你的代碼的可移植性。

也就是說，把所有的析構函數都不加思索的聲明為虛擬的和從不把它們聲明為虛擬的一樣，都是不明智的行為。實際上，很多人得除了這樣的結論：當且僅當一個類有至少一個虛函數的時候，才把析構函數聲明為虛擬的。

實際上，即使你的類中沒有虛函數，你還是有可能被非虛析構函數的問題咬上一口。例如 std::string 就沒有虛函數，但是一些被誤導的程序員有時會把它當作基類來使用：

class SpecialString: public std::string {

// bad idea! std::string has a

??? ...????????????????????? ??? // non-virtual destructor
}

乍一看，這可能沒什么問題，但是一旦你把一個指向 SpecialString 的指針轉換成一個 string ，并用這個指針來刪除 SpecialString 對象的時候，你馬上就被帶進了未定義行為的深潭。

SpecialString *pss = new SpecialString("Impending Doom");

std::string *ps;

...

ps = pss;? // SpecialString* --> std::string*

?

delete ps;? // undefined! In practice, *ps's Specialstring resources

?????????? ? // will be leaked, because the SpecialString destructor won't??????? // be called

同樣的結果還會出現在其它沒有虛析構函數的類中，例如所有的 STL 容器類型（例如： vector, list, set, tr1::unordered_map 等等）。如果你曾經對于從一個標準容器或其它帶有非虛析構函數的類繼承，那么徹底打消這個想法。（不幸的是 C++ 沒有提供像 C#(sealed) 和 Java(final) 類似的拒絕繼承的語言機制）

有時候，把析構函數設定為 pure virtual 是非常方便的。一個 pure virtual 函數可以讓一個類成為抽象類。有時，你可能需要讓你的類成為一個 abstract class ，但是你一時又找不到合適的純虛函數。怎么辦呢？因為一個抽象類往往是要被作為基類的，而一個基類往往又應該有一個虛析構函數。這樣一來：聲明一個 pure virtual destructor 就是一個不錯的主意。一箭雙雕。

class AWOV {? // AWOV = "Abstract w/o Virtuals"

public :

??? virtual ~AWOV() = 0; // declare pure virtual destructor

};

這個類有一個純虛函數，因此這是以個抽象基類，并且這個類有一個虛析構函數，這也使你遠離了析構函數的問題，唯一要注意的，就是一定要為純虛析構函數提供一份實現。

虛析構函數的工作方式是從最深的派生類的析構函數依次調用其基類的析構函數，編譯器會生成生成一個從派生類到基類的 ~AWOV 的調用。如果你沒有提供析構函數的實現，鏈接器就會抱怨錯誤。

所以，你只應該把多態基類的析構函數聲明為虛擬的。只有你想通過基類接口來操作派生類的時候，一個基類才是多態的。 TimeKeeper 就是一個多態基類，因為我們需要用一個 TimeKeeper* 來操作 AtomicClock 和 WaterClock 對象。

另外，并不是所有的基類都要按照多態的方式來設計和使用。 Std::string 和 STL 中的容器類型就都不具備多態性。一些類被設計成基類，但是卻不應該按照多態的方式來使用，例如 input_iterator_tag 就是一個例子，你并不需要用基類接口來操縱派生類。結果是，他們也不需要虛擬析構函數。

時時刻刻讓自己記住

l ???????? 應該為多態基類聲明虛擬析構函數。如果一個類有一個虛函數，那么它也應該有一個虛析構函數

l ???????? 如果一個類不是被設計為基類或者它們并不是按照多態的方式來使用的，不要為它們聲明虛析構函數

posted on 2005-11-10 16:43 nacci 閱讀(2201) 評論(3)  編輯 收藏 引用 所屬分類: C++漫談