關于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
????????
如果一個類不是被設計為基類或者它們并不是按照多態的方式來使用的，不要為它們聲明虛析構函數