關于virtual desctructor的詳細討論。同樣來自于《Effective C++》3rd Edition。
跟蹤時間是很平常的任務，所以開發(fā)一個名為
TimeKeeper
的基類，并讓不同的派生類來實現(xiàn)不同的計時方法是很合理的事情：
class
TimeKeeper {
public
:
??? TimeKeeper();
??? ~TimeKeeper();
??? ...
};
?
class
AtomicClock: public TimeKeeper { ... };
class
WaterClock: public TimeKeeper { ... };
class
WristWatch: public TimeKeeper{ ... };
很多用戶都希望直接用這些類來計數(shù)，而對于他們究竟是如何實現(xiàn)的并不關心。于是一個我們可以用一個
Factory function
——創(chuàng)建一個派生類對象并返回一個基類指針的函數(shù)——返回一個指向
TimeKeeper
的指針。
TimeKeeper* getTimeKeeper(); // returns a pointer to a dynamically
????????????????????????
?
???
// allocated object of a class derived
????????????????????????
?
???
// from TimeKeeper
通常，
factory function
返回的對象都是創(chuàng)建在堆上的，當用戶使用完計數(shù)器的時候把對象析構掉是很重要的：
TimeKeeper *ptk = getTimeKeeper(); // get dynamically allocated object
???????????????????????????
??
?????
// from TimeKeeper hierarchy
...???????????????????????? ?? ?????// use it
delete
ptk;???????????????????? ?? // release it to avoid resource leak
但是，依賴用戶來執(zhí)行刪除是錯誤的重要來源。條款
18
介紹了如何修改
Factory function
的接口來避免這些常見的用戶錯誤，但是，這些目前都是次要的，因為在上面的代碼中還存在更為嚴重的問題：即使客戶執(zhí)行的正確的動作，你還是無法預期你的程序能夠正確執(zhí)行。
問題在于
getTimeKeeper
返回了一個派生類對象（例如
:AutoicClock
），但是這個對象卻通過基類的指針來刪除（一個指向
Timekeeper
的指針），并且這個基類沒有虛析構函數(shù)。這種組合是制造災難的良方，因為
C++
規(guī)定：用不帶有虛析構函數(shù)的基類的指針來刪除一個派生類，其結果是未定的。通常在運行時發(fā)生的情況是這個對象的派生類部分沒有被析構。如果
getTimeKeeper
返回一個指向
AtomicClock
對象的指針，那么
AtomicClock
中派生類的部分（例如在
AtomicClock
中聲明的數(shù)據(jù)成員）將不會被正確的析構，實際上
AtomicClock
的析構函數(shù)都根本不會被調(diào)用。但是，基類的部分，卻會被正確的清除，這就造就了一個“畸形”的
partially destroyed object
。這是一個非常棒的泄漏資源、破壞數(shù)據(jù)的方法，它會讓你在調(diào)試器上花費大量的精力。
解決這個問題的方法很簡單，給派生類加上一個虛析構函數(shù)。這樣派生類對象就會如你所愿，被正確的清除：
class
TimeKeeper {
public
:
??? TimeKeeper();
???
virtual ~TimeKeeper();
??? ...
};
?
TimeKeeper *ptk = getTimeKeeper();
...???????????????????????????
delete
ptk;???????????????? // now behaves correctlhy
像
TimeKeeper
這樣的基類，除了析構函數(shù)外，通常會包含其它的虛函數(shù)。因為虛函數(shù)的目標就是讓派生類來訂制基類的實現(xiàn)。例如，
getCurrentTime
，在不同的派生類中就會有不同的實現(xiàn)（注：其實
getTimeKeeper
也可以是一個虛函數(shù)）。任何一個擁有虛函數(shù)的類都應該包含一個虛析構函數(shù)。
如果一個類沒有虛函數(shù)呢，這也就意味著這個類并不是被當作基類來使用的。當遇到這種情況的時候，聲明一個虛析構函數(shù)往往不是一個好主意。考慮一個用來表示二維空間中的某點的類：
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
的析構函數(shù)是虛擬的，故事就完全不一樣了。
虛函數(shù)的實現(xiàn)需要對象承載某些額外信息，這些信息用來在運行時對虛函數(shù)的調(diào)用進行正確的轉(zhuǎn)發(fā)。這個額外的信息使通過一個
vtpr
來實現(xiàn)的。
Vptr
指向一個存放函數(shù)指針（
vtbl
）的數(shù)組，每一個具有虛函數(shù)的類都有一個對應的
vtbl
。當一個對象的虛函數(shù)被調(diào)用的時候，該對象的
vtpr
和
vtbl
組合來完成定位正確的函數(shù)調(diào)用的工作。
這里，虛函數(shù)如何實現(xiàn)的并不重要。重要的是如果
Point
包含了一個虛函數(shù)，對象將會長胖。在一個
32 bits
的機器上，它將會從
64 bits
長到
96 bits
；在
64 bit
的機器上，它將會從
64 bits
長到
128 bits
。這個額外的
vtpr
的存在讓對象的體積增長了
50%~100%
。
Point
對象也不再能夠放到一個
64-bit
寄存器中了。另外，
Point
對象也不再和
C
語言的保持兼容，因為
C
語言中沒有
vrpr
機制。結果是，你要想使用該
Point
對象，除非自己來實現(xiàn)
vtpr
和
vtpl
機制，而這樣做，往往又會降低你的代碼的可移植性。
也就是說，把所有的析構函數(shù)都不加思索的聲明為虛擬的和從不把它們聲明為虛擬的一樣，都是不明智的行為。實際上，很多人得除了這樣的結論：當且僅當一個類有至少一個虛函數(shù)的時候，才把析構函數(shù)聲明為虛擬的。
實際上，即使你的類中沒有虛函數(shù)，你還是有可能被非虛析構函數(shù)的問題咬上一口。例如
std::string
就沒有虛函數(shù)，但是一些被誤導的程序員有時會把它當作基類來使用：
class
SpecialString: public std::string {
// bad idea! std::string has a
??? ...????????????????????? ??? // non-virtual destructor
}
乍一看，這可能沒什么問題，但是一旦你把一個指向
SpecialString
的指針轉(zhuǎn)換成一個
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
同樣的結果還會出現(xiàn)在其它沒有虛析構函數(shù)的類中，例如所有的
STL
容器類型（例如：
vector, list, set, tr1::unordered_map
等等）。如果你曾經(jīng)對于從一個標準容器或其它帶有非虛析構函數(shù)的類繼承，那么徹底打消這個想法。（不幸的是
C++
沒有提供像
C#(sealed)
和
Java(final)
類似的拒絕繼承的語言機制）
有時候，把析構函數(shù)設定為
pure virtual
是非常方便的。一個
pure virtual
函數(shù)可以讓一個類成為抽象類。有時，你可能需要讓你的類成為一個
abstract class
，但是你一時又找不到合適的純虛函數(shù)。怎么辦呢？因為一個抽象類往往是要被作為基類的，而一個基類往往又應該有一個虛析構函數(shù)。這樣一來：聲明一個
pure virtual destructor
就是一個不錯的主意。一箭雙雕。
class
AWOV {? // AWOV = "Abstract w/o Virtuals"
public
:
???
virtual ~AWOV() = 0; // declare pure virtual destructor
};
這個類有一個純虛函數(shù)，因此這是以個抽象基類，并且這個類有一個虛析構函數(shù)，這也使你遠離了析構函數(shù)的問題，唯一要注意的，就是一定要為純虛析構函數(shù)提供一份實現(xiàn)。
虛析構函數(shù)的工作方式是從最深的派生類的析構函數(shù)依次調(diào)用其基類的析構函數(shù)，編譯器會生成生成一個從派生類到基類的
~AWOV
的調(diào)用。如果你沒有提供析構函數(shù)的實現(xiàn)，鏈接器就會抱怨錯誤。
所以，你只應該把多態(tài)基類的析構函數(shù)聲明為虛擬的。只有你想通過基類接口來操作派生類的時候，一個基類才是多態(tài)的。
TimeKeeper
就是一個多態(tài)基類，因為我們需要用一個
TimeKeeper*
來操作
AtomicClock
和
WaterClock
對象。
另外，并不是所有的基類都要按照多態(tài)的方式來設計和使用。
Std::string
和
STL
中的容器類型就都不具備多態(tài)性。一些類被設計成基類，但是卻不應該按照多態(tài)的方式來使用，例如
input_iterator_tag
就是一個例子，你并不需要用基類接口來操縱派生類。結果是，他們也不需要虛擬析構函數(shù)。
時時刻刻讓自己記住
l
????????
應該為多態(tài)基類聲明虛擬析構函數(shù)。如果一個類有一個虛函數(shù)，那么它也應該有一個虛析構函數(shù)
l
????????
如果一個類不是被設計為基類或者它們并不是按照多態(tài)的方式來使用的，不要為它們聲明虛析構函數(shù)