C++中的虛擬函式(virtual function)
阿新 • • 發佈：2019-02-13
1.簡介
虛擬函式是C++中用於實現多型(polymorphism)的機制。核心理念就是通過基類訪問派生類定義的函式。假設我們有下面的類層次：
class A
{
public:
virtual void foo() { cout << "A::foo() is called" << endl;}
};
class B: public A
{
public:
virtual void foo() { cout << "B::foo() is called" << endl;}
};
那麼，在使用的時候，我們可以：
A * a = new B();
a->foo(); // 在這裡，a雖然是指向A的指標，但是被呼叫的函式(foo)卻是B的!
這個例子是虛擬函式的一個典型應用，通過這個例子，也許你就對虛擬函式有了一些概念。它虛就虛在所謂“推遲聯編”或者“動態聯編”上，一個類函式的呼叫並不是在編譯時刻被確定的，而是在執行時刻被確定的。由於編寫程式碼的時候並不能確定被呼叫的是基類的函式還是哪個派生類的函式，所以被成為“虛”函式。
虛擬函式只能藉助於指標或者引用來達到多型的效果，如果是下面這樣的程式碼，則雖然是虛擬函式，但它不是多型的：
class A
{
public:
virtual void foo();
};
class B: public A
{
virtual void foo();
};
void bar()
{
A a;
a.foo(); // A::foo()被呼叫
}
1.1 多型
在瞭解了虛擬函式的意思之後，再考慮什麼是多型就很容易了。仍然針對上面的類層次，但是使用的方法變的複雜了一些：
void bar(A * a)
{
a->foo(); // 被呼叫的是A::foo() 還是B::foo()？
}
因為foo()是個虛擬函式，所以在bar這個函式中，只根據這段程式碼，無從確定這裡被呼叫的是A::foo()還是B::foo()，但是可以肯定的說：如果a指向的是A類的例項，則A::foo()被呼叫，如果a指向的是B類的例項，則B::foo()被呼叫。
這種同一程式碼可以產生不同效果的特點，被稱為“多型”。
1.2 多型有什麼用？
多型這麼神奇，但是能用來做什麼呢？這個命題我難以用一兩句話概括，一般的C++教程（或者其它面嚮物件語言的教程）都用一個畫圖的例子來展示多型的用途，我就不再重複這個例子了，如果你不知道這個例子，隨便找本書應該都有介紹。我試圖從一個抽象的角度描述一下，回頭再結合那個畫圖的例子，也許你就更容易理解。
在面向物件的程式設計中，首先會針對資料進行抽象（確定基類）和繼承（確定派生類），構成類層次。這個類層次的使用者在使用它們的時候，如果仍然在需要基類的時候寫針對基類的程式碼，在需要派生類的時候寫針對派生類的程式碼，就等於類層次完全暴露在使用者面前。如果這個類層次有任何的改變（增加了新類），都需要使用者“知道”（針對新類寫程式碼）。這樣就增加了類層次與其使用者之間的耦合，有人把這種情況列為程式中的“bad smell”之一。
多型可以使程式設計師脫離這種窘境。再回頭看看1.1中的例子，bar()作為A-B這個類層次的使用者，它並不知道這個類層次中有多少個類，每個類都叫什麼，但是一樣可以很好的工作，當有一個C類從A類派生出來後，bar()也不需要“知道”（修改）。這完全歸功於多型--編譯器針對虛擬函式產生了可以在執行時刻確定被呼叫函式的程式碼。
1.3 如何“動態聯編”
編譯器是如何針對虛擬函式產生可以再執行時刻確定被呼叫函式的程式碼呢？也就是說，虛擬函式實際上是如何被編譯器處理的呢？Lippman在深度探索C++物件模型[1]中的不同章節講到了幾種方式，這裡把“標準的”方式簡單介紹一下。
我所說的“標準”方式，也就是所謂的“VTABLE”機制。編譯器發現一個類中有被宣告為virtual的函式，就會為其搞一個虛擬函式表，也就是VTABLE。VTABLE實際上是一個函式指標的陣列，每個虛擬函式佔用這個陣列的一個slot。一個類只有一個VTABLE，不管它有多少個例項。派生類有自己的VTABLE，但是派生類的VTABLE與基類的VTABLE有相同的函式排列順序，同名的虛擬函式被放在兩個陣列的相同位置上。在建立類例項的時候，編譯器還會在每個例項的記憶體佈局中增加一個vptr欄位，該欄位指向本類的VTABLE。通過這些手段，編譯器在看到一個虛擬函式呼叫的時候，就會將這個呼叫改寫，針對1.1中的例子：
void bar(A * a)
{
a->foo();
}
會被改寫為：
void bar(A * a)
{
(a->vptr[1])();
}
因為派生類和基類的foo()函式具有相同的VTABLE索引，而他們的vptr又指向不同的VTABLE，因此通過這樣的方法可以在執行時刻決定呼叫哪個foo()函式。
雖然實際情況遠非這麼簡單，但是基本原理大致如此。
1.4 overload和override
虛擬函式總是在派生類中被改寫，這種改寫被稱為“override”。我經常混淆“overload”和“override”這兩個單詞。但是隨著各類C++的書越來越多，後來的程式設計師也許不會再犯我犯過的錯誤了。但是我打算澄清一下：
override是指派生類重寫基類的虛擬函式，就象我們前面B類中重寫了A類中的foo()函式。重寫的函式必須有一致的引數表和返回值（C++標準允許返回值不同的情況，這個我會在“語法”部分簡單介紹，但是很少編譯器支援這個feature）。這個單詞好象一直沒有什麼合適的中文詞彙來對應，有人譯為“覆蓋”，還貼切一些。
overload約定成俗的被翻譯為“過載”。是指編寫一個與已有函式同名但是引數表不同的函式。例如一個函式即可以接受整型數作為引數，也可以接受浮點數作為引數。
2. 虛擬函式的語法
虛擬函式的標誌是“virtual”關鍵字。
2.1 使用virtual關鍵字
考慮下面的類層次：
class A
{
public:
virtual void foo();
};
class B: public A
{
public:
void foo(); // 沒有virtual關鍵字!
};
class C: public B // 從B繼承，不是從A繼承！
{
public:
void foo(); // 也沒有virtual關鍵字！
};
這種情況下，B::foo()是虛擬函式，C::foo()也同樣是虛擬函式。因此，可以說，基類宣告的虛擬函式，在派生類中也是虛擬函式，即使不再使用virtual關鍵字。
2.2 純虛擬函式
如下宣告表示一個函式為純虛擬函式：
class A
{
public:
virtual void foo()=0; // =0標誌一個虛擬函式為純虛擬函式
};
一個函式宣告為純虛後，純虛擬函式的意思是：我是一個抽象類！不要把我例項化！純虛擬函式用來規範派生類的行為，實際上就是所謂的“介面”。它告訴使用者，我的派生類都會有這個函式。
2.3 虛解構函式
解構函式也可以是虛的，甚至是純虛的。例如：
class A
{
public:
virtual ~A()=0; // 純虛解構函式
};
當一個類打算被用作其它類的基類時，它的解構函式必須是虛的。考慮下面的例子：
class A
{
public:
A() { ptra_ = new char[10];}
~A() { delete[] ptra_;} // 非虛解構函式
private:
char * ptra_;
};
class B: public A
{
public:
B() { ptrb_ = new char[20];}
~B() { delete[] ptrb_;}
private:
char * ptrb_;
};
void foo()
{
A * a = new B;
delete a;
}
在這個例子中，程式也許不會象你想象的那樣執行，在執行delete a的時候，實際上只有A::~A()被呼叫了，而B類的解構函式並沒有被呼叫！這是否有點兒可怕？
如果將上面A::~A()改為virtual，就可以保證B::~B()也在delete a的時候被呼叫了。因此基類的解構函式都必須是virtual的。
純虛的解構函式並沒有什麼作用，是虛的就夠了。通常只有在希望將一個類變成抽象類（不能例項化的類），而這個類又沒有合適的函式可以被純虛化的時候，可以使用純虛的解構函式來達到目的。
2.4 虛建構函式？
3. 虛擬函式使用技巧 3.1 private的虛擬函式
考慮下面的例子：
class A
{
public:
void foo() { bar();}
private:
virtual void bar() { ...}
};
class B: public A
{
private:
virtual void bar() { ...}
};
在這個例子中，雖然bar()在A類中是private的，但是仍然可以出現在派生類中，並仍然可以與public或者protected的虛擬函式一樣產生多型的效果。並不會因為它是private的，就發生A::foo()不能訪問B::bar()的情況，也不會發生B::bar()對A::bar()的override不起作用的情況。
這種寫法的語意是：A告訴B，你最好override我的bar()函式，但是你不要管它如何使用，也不要自己呼叫這個函式。
3.2 建構函式和解構函式中的虛擬函式呼叫
一個類的虛擬函式在它自己的建構函式和解構函式中被呼叫的時候，它們就變成普通函數了，不“虛”了。也就是說不能在建構函式和解構函式中讓自己“多型”。例如：
class A
{
public:
A() { foo();} // 在這裡，無論如何都是A::foo()被呼叫！
~A() { foo();} // 同上
virtual void foo();
};
class B: public A
{
public:
virtual void foo();
};
void bar()
{
A * a = new B;
delete a;
}
如果你希望delete a的時候，會導致B::foo()被呼叫，那麼你就錯了。同樣，在new B的時候，A的建構函式被呼叫，但是在A的建構函式中，被呼叫的是A::foo()而不是B::foo()。
3.3 多繼承中的虛擬函式 3.4 什麼時候使用虛擬函式
在你設計一個基類的時候，如果發現一個函式需要在派生類裡有不同的表現，那麼它就應該是虛的。從設計的角度講，出現在基類中的虛擬函式是介面，出現在派生類中的虛擬函式是介面的具體實現。通過這樣的方法，就可以將物件的行為抽象化。
以設計模式[2]中Factory Method模式為例，Creator的factoryMethod()就是虛擬函式，派生類override這個函式後，產生不同的Product類，被產生的Product類被基類的AnOperation()函式使用。基類的AnOperation()函式針對Product類進行操作，當然Product類一定也有多型（虛擬函式）。
另外一個例子就是集合操作，假設你有一個以A類為基類的類層次，又用了一個std::vector<A *>來儲存這個類層次中不同類的例項指標，那麼你一定希望在對這個集合中的類進行操作的時候，不要把每個指標再cast回到它原來的型別（派生類），而是希望對他們進行同樣的操作。那麼就應該將這個“一樣的操作”宣告為virtual。
現實中，遠不只我舉的這兩個例子，但是大的原則都是我前面說到的“如果發現一個函式需要在派生類裡有不同的表現，那麼它就應該是虛的”。這句話也可以反過來說：“如果你發現基類提供了虛擬函式，那麼你最好override它”。
4.參考資料
[1] 深度探索C++物件模型，Stanley B.Lippman，侯捷譯
[2] Design Patterns, Elements of Reusable Object-Oriented Software, GOF
虛擬函式是C++中用於實現多型(polymorphism)的機制。核心理念就是通過基類訪問派生類定義的函式。假設我們有下面的類層次：
class A
{
public:
virtual void foo() { cout << "A::foo() is called" << endl;}
};
class B: public A
{
public:
virtual void foo() { cout << "B::foo() is called" << endl;}
};
那麼，在使用的時候，我們可以：
A * a = new B();
a->foo(); // 在這裡，a雖然是指向A的指標，但是被呼叫的函式(foo)卻是B的!
這個例子是虛擬函式的一個典型應用，通過這個例子，也許你就對虛擬函式有了一些概念。它虛就虛在所謂“推遲聯編”或者“動態聯編”上，一個類函式的呼叫並不是在編譯時刻被確定的，而是在執行時刻被確定的。由於編寫程式碼的時候並不能確定被呼叫的是基類的函式還是哪個派生類的函式，所以被成為“虛”函式。
虛擬函式只能藉助於指標或者引用來達到多型的效果，如果是下面這樣的程式碼，則雖然是虛擬函式，但它不是多型的：
class A
{
public:
virtual void foo();
};
class B: public A
{
virtual void foo();
};
void bar()
{
A a;
a.foo(); // A::foo()被呼叫
}
1.1 多型
在瞭解了虛擬函式的意思之後，再考慮什麼是多型就很容易了。仍然針對上面的類層次，但是使用的方法變的複雜了一些：
void bar(A * a)
{
a->foo(); // 被呼叫的是A::foo() 還是B::foo()？
}
因為foo()是個虛擬函式，所以在bar這個函式中，只根據這段程式碼，無從確定這裡被呼叫的是A::foo()還是B::foo()，但是可以肯定的說：如果a指向的是A類的例項，則A::foo()被呼叫，如果a指向的是B類的例項，則B::foo()被呼叫。
這種同一程式碼可以產生不同效果的特點，被稱為“多型”。
1.2 多型有什麼用？
多型這麼神奇，但是能用來做什麼呢？這個命題我難以用一兩句話概括，一般的C++教程（或者其它面嚮物件語言的教程）都用一個畫圖的例子來展示多型的用途，我就不再重複這個例子了，如果你不知道這個例子，隨便找本書應該都有介紹。我試圖從一個抽象的角度描述一下，回頭再結合那個畫圖的例子，也許你就更容易理解。
在面向物件的程式設計中，首先會針對資料進行抽象（確定基類）和繼承（確定派生類），構成類層次。這個類層次的使用者在使用它們的時候，如果仍然在需要基類的時候寫針對基類的程式碼，在需要派生類的時候寫針對派生類的程式碼，就等於類層次完全暴露在使用者面前。如果這個類層次有任何的改變（增加了新類），都需要使用者“知道”（針對新類寫程式碼）。這樣就增加了類層次與其使用者之間的耦合，有人把這種情況列為程式中的“bad smell”之一。
多型可以使程式設計師脫離這種窘境。再回頭看看1.1中的例子，bar()作為A-B這個類層次的使用者，它並不知道這個類層次中有多少個類，每個類都叫什麼，但是一樣可以很好的工作，當有一個C類從A類派生出來後，bar()也不需要“知道”（修改）。這完全歸功於多型--編譯器針對虛擬函式產生了可以在執行時刻確定被呼叫函式的程式碼。
1.3 如何“動態聯編”
編譯器是如何針對虛擬函式產生可以再執行時刻確定被呼叫函式的程式碼呢？也就是說，虛擬函式實際上是如何被編譯器處理的呢？Lippman在深度探索C++物件模型[1]中的不同章節講到了幾種方式，這裡把“標準的”方式簡單介紹一下。
我所說的“標準”方式，也就是所謂的“VTABLE”機制。編譯器發現一個類中有被宣告為virtual的函式，就會為其搞一個虛擬函式表，也就是VTABLE。VTABLE實際上是一個函式指標的陣列，每個虛擬函式佔用這個陣列的一個slot。一個類只有一個VTABLE，不管它有多少個例項。派生類有自己的VTABLE，但是派生類的VTABLE與基類的VTABLE有相同的函式排列順序，同名的虛擬函式被放在兩個陣列的相同位置上。在建立類例項的時候，編譯器還會在每個例項的記憶體佈局中增加一個vptr欄位，該欄位指向本類的VTABLE。通過這些手段，編譯器在看到一個虛擬函式呼叫的時候，就會將這個呼叫改寫，針對1.1中的例子：
void bar(A * a)
{
a->foo();
}
會被改寫為：
void bar(A * a)
{
(a->vptr[1])();
}
因為派生類和基類的foo()函式具有相同的VTABLE索引，而他們的vptr又指向不同的VTABLE，因此通過這樣的方法可以在執行時刻決定呼叫哪個foo()函式。
雖然實際情況遠非這麼簡單，但是基本原理大致如此。
1.4 overload和override
虛擬函式總是在派生類中被改寫，這種改寫被稱為“override”。我經常混淆“overload”和“override”這兩個單詞。但是隨著各類C++的書越來越多，後來的程式設計師也許不會再犯我犯過的錯誤了。但是我打算澄清一下：
override是指派生類重寫基類的虛擬函式，就象我們前面B類中重寫了A類中的foo()函式。重寫的函式必須有一致的引數表和返回值（C++標準允許返回值不同的情況，這個我會在“語法”部分簡單介紹，但是很少編譯器支援這個feature）。這個單詞好象一直沒有什麼合適的中文詞彙來對應，有人譯為“覆蓋”，還貼切一些。
overload約定成俗的被翻譯為“過載”。是指編寫一個與已有函式同名但是引數表不同的函式。例如一個函式即可以接受整型數作為引數，也可以接受浮點數作為引數。
2. 虛擬函式的語法
虛擬函式的標誌是“virtual”關鍵字。
2.1 使用virtual關鍵字
考慮下面的類層次：
class A
{
public:
virtual void foo();
};
class B: public A
{
public:
void foo(); // 沒有virtual關鍵字!
};
class C: public B // 從B繼承，不是從A繼承！
{
public:
void foo(); // 也沒有virtual關鍵字！
};
這種情況下，B::foo()是虛擬函式，C::foo()也同樣是虛擬函式。因此，可以說，基類宣告的虛擬函式，在派生類中也是虛擬函式，即使不再使用virtual關鍵字。
2.2 純虛擬函式
如下宣告表示一個函式為純虛擬函式：
class A
{
public:
virtual void foo()=0; // =0標誌一個虛擬函式為純虛擬函式
};
一個函式宣告為純虛後，純虛擬函式的意思是：我是一個抽象類！不要把我例項化！純虛擬函式用來規範派生類的行為，實際上就是所謂的“介面”。它告訴使用者，我的派生類都會有這個函式。
2.3 虛解構函式
解構函式也可以是虛的，甚至是純虛的。例如：
class A
{
public:
virtual ~A()=0; // 純虛解構函式
};
當一個類打算被用作其它類的基類時，它的解構函式必須是虛的。考慮下面的例子：
class A
{
public:
A() { ptra_ = new char[10];}
~A() { delete[] ptra_;} // 非虛解構函式
private:
char * ptra_;
};
class B: public A
{
public:
B() { ptrb_ = new char[20];}
~B() { delete[] ptrb_;}
private:
char * ptrb_;
};
void foo()
{
A * a = new B;
delete a;
}
在這個例子中，程式也許不會象你想象的那樣執行，在執行delete a的時候，實際上只有A::~A()被呼叫了，而B類的解構函式並沒有被呼叫！這是否有點兒可怕？
如果將上面A::~A()改為virtual，就可以保證B::~B()也在delete a的時候被呼叫了。因此基類的解構函式都必須是virtual的。
純虛的解構函式並沒有什麼作用，是虛的就夠了。通常只有在希望將一個類變成抽象類（不能例項化的類），而這個類又沒有合適的函式可以被純虛化的時候，可以使用純虛的解構函式來達到目的。
2.4 虛建構函式？
建構函式不能是虛的。
a) 從儲存空間角度
虛擬函式對應一個vtable，這大家都知道，可是這個vtable其實是儲存在物件的記憶體空間的。問題出來了，如果建構函式是虛的，就需要通過 vtable來呼叫，可是物件還沒有例項化，也就是記憶體空間還沒有，無法找到vtable，所以建構函式不能是虛擬函式。
b) 從使用角度
虛擬函式主要用於在資訊不全的情況下，能使過載的函式得到對應的呼叫。建構函式本身就是要初始化例項，那使用虛擬函式也沒有實際意義呀。所以建構函式沒有必要是虛擬函式。
虛擬函式的作用在於通過父類的指標或者引用來呼叫它的時候能夠變成呼叫子類的那個成員函式。而建構函式是在建立物件時自動呼叫的，不可能通過父類的指標或者引用去呼叫，因此也就規定建構函式不能是虛擬函式。
c) 建構函式不需要是虛擬函式，也不允許是虛擬函式，因為建立一個物件時我們總是要明確指定物件的型別，儘管我們可能通過實驗室的基類的指標或引用去訪問它。但析構卻不一定，我們往往通過基類的指標來銷燬物件。這時候如果解構函式不是虛擬函式，就不能正確識別物件型別從而不能正確呼叫解構函式。
d) 從實現上看，vbtl在建構函式呼叫後才建立，因而建構函式不可能成為虛擬函式
從實際含義上看，在呼叫建構函式時還不能確定物件的真實型別（因為子類會調父類的建構函式）；而且建構函式的作用是提供初始化，在物件生命期只執行一次，不是物件的動態行為，也沒有太大的必要成為虛擬函式
e) 當一個建構函式被呼叫時，它做的首要的事情之一是初始化它的V P T R。因此，它只能知道它是“當前”類的，而完全忽視這個物件後面是否還有繼承者。當編譯器為這個建構函式產生程式碼時，它是為這個類的建構函式產生程式碼- -既不是為基類，也不是為它的派生類（因為類不知道誰繼承它）。
所以它使用的V P T R必須是對於這個類的V TA B L E。而且，只要它是最後的建構函式呼叫，那麼在這個物件的生命期內， V P T R將保持被初始化為指向這個V TA B L E, 但如果接著還有一個更晚派生的建構函式被呼叫，這個建構函式又將設定V P T R指向它的 V TA B L E，等.直到最後的建構函式結束。V P T R的狀態是由被最後呼叫的建構函式確定的。這就是為什麼建構函式呼叫是從基類到更加派生
類順序的另一個理由。
但是，當這一系列建構函式呼叫正發生時，每個建構函式都已經設定V P T R指向它自己的 V TA B L E。如果函式呼叫使用虛機制，它將只產生通過它自己的V TA B L E的呼叫，而不是最後的V TA B L E（所有建構函式被呼叫後才會有最後的V TA B L E）。
3. 虛擬函式使用技巧 3.1 private的虛擬函式
考慮下面的例子：
class A
{
public:
void foo() { bar();}
private:
virtual void bar() { ...}
};
class B: public A
{
private:
virtual void bar() { ...}
};
在這個例子中，雖然bar()在A類中是private的，但是仍然可以出現在派生類中，並仍然可以與public或者protected的虛擬函式一樣產生多型的效果。並不會因為它是private的，就發生A::foo()不能訪問B::bar()的情況，也不會發生B::bar()對A::bar()的override不起作用的情況。
這種寫法的語意是：A告訴B，你最好override我的bar()函式，但是你不要管它如何使用，也不要自己呼叫這個函式。
3.2 建構函式和解構函式中的虛擬函式呼叫
一個類的虛擬函式在它自己的建構函式和解構函式中被呼叫的時候，它們就變成普通函數了，不“虛”了。也就是說不能在建構函式和解構函式中讓自己“多型”。例如：
class A
{
public:
A() { foo();} // 在這裡，無論如何都是A::foo()被呼叫！
~A() { foo();} // 同上
virtual void foo();
};
class B: public A
{
public:
virtual void foo();
};
void bar()
{
A * a = new B;
delete a;
}
如果你希望delete a的時候，會導致B::foo()被呼叫，那麼你就錯了。同樣，在new B的時候，A的建構函式被呼叫，但是在A的建構函式中，被呼叫的是A::foo()而不是B::foo()。
3.3 多繼承中的虛擬函式 3.4 什麼時候使用虛擬函式
在你設計一個基類的時候，如果發現一個函式需要在派生類裡有不同的表現，那麼它就應該是虛的。從設計的角度講，出現在基類中的虛擬函式是介面，出現在派生類中的虛擬函式是介面的具體實現。通過這樣的方法，就可以將物件的行為抽象化。
以設計模式[2]中Factory Method模式為例，Creator的factoryMethod()就是虛擬函式，派生類override這個函式後，產生不同的Product類，被產生的Product類被基類的AnOperation()函式使用。基類的AnOperation()函式針對Product類進行操作，當然Product類一定也有多型（虛擬函式）。
另外一個例子就是集合操作，假設你有一個以A類為基類的類層次，又用了一個std::vector<A *>來儲存這個類層次中不同類的例項指標，那麼你一定希望在對這個集合中的類進行操作的時候，不要把每個指標再cast回到它原來的型別（派生類），而是希望對他們進行同樣的操作。那麼就應該將這個“一樣的操作”宣告為virtual。
現實中，遠不只我舉的這兩個例子，但是大的原則都是我前面說到的“如果發現一個函式需要在派生類裡有不同的表現，那麼它就應該是虛的”。這句話也可以反過來說：“如果你發現基類提供了虛擬函式，那麼你最好override它”。
4.參考資料
[1] 深度探索C++物件模型，Stanley B.Lippman，侯捷譯
[2] Design Patterns, Elements of Reusable Object-Oriented Software, GOF