這篇文章主要介紹了C++虛函數及虛函數表,内容非常詳細,思路清晰,需要的朋友可以參考下。
C++中的虛函數的作用主要是實作了多态的機制。關于多态,簡而言之就是用父類型别的指針指向其子類的執行個體,然後通過父類的指針調用實際子類的成員函數。這種技術可以讓父類的指針有“多種形态”,這是一種泛型技術。所謂泛型技術,說白了就是試圖使用不變的代碼來實作可變的算法。比如:模闆技術,RTTI技術,虛函數技術,要麼是試圖做到在編譯時決議,要麼試圖做到運作時決議。
關于虛函數的使用方法,我在這裡不做過多的闡述。大家可以看看相關的C++的書籍。在這篇文章中,我隻想從虛函數的實作機制上面為大家 一個清晰的剖析。
當然,相同的文章在網上也出現過一些了,但我總感覺這些文章不是很容易閱讀,大段大段的代碼,沒有圖檔,沒有詳細的說明,沒有比較,沒有舉一反三。不利于學習和閱讀,是以這是我想寫下這篇文章的原因。也希望大家多給我提意見。
言歸正傳,讓我們一起進入虛函數的世界。
1.虛函數的定義
虛函數必須是類的非靜态成員函數(且非構造函數),其通路權限是public(可以定義為private or proteceted, 但是對于多态來說,沒有意義。),在基類的類定義中定義虛函數的一般形式:
virtual 函數傳回值類型 虛函數名(形參表)
{ 函數體 }
虛函數的作用是實作動态聯編,也就是在程式的運作階段動态地選擇合适的成員函數,在定義了虛函數後,可以在基類的派生類中對虛函數重新定義(形式也是:virtual 函數傳回值類型 虛函數名(形參表){ 函數體 }),在派生類中重新定義的函數應與虛函數具有相同的形參個數和形參類型。以實作統一的接口,不同定義過程。如果在派生類中沒有對虛函數重新定義,則它繼承其基類的虛函數。當程式發現虛函數名前的關鍵字virtual後,會自動将其作為動态聯編處理,即在程式運作時動态地選擇合适的成員
實作動态聯編需要三個條件:
1、 必須把需要動态聯編的行為定義為類的公共屬性的虛函數。
2、 類之間存在子類型關系,一般表現為一個類從另一個類公有派生而來。
3、 必須先使用基類指針指向子類型的對象,然後直接或者間接使用基類指針調用虛函數。
定義虛函數的限制:
(1)非類的成員函數不能定義為虛函數,類的成員函數中靜态成員函數和構造函數也不能定義為虛函數,但可以将析構函數定義為虛函數。實際上,優秀的程式員常常把基類的析構函數定義為虛函數。因為,将基類的析構函數定義為虛函數後,當利用delete删除一個指向派生類定義的對象指針時,系統會調用相應的類的析構函數。而不将析構函數定義為虛函數時,隻調用基類的析構函數。
(2)隻需要在聲明函數的類體中使用關鍵字“virtual”将函數聲明為虛函數,而定義函數時不需要使用關鍵字“virtual”。
(3)如果聲明了某個成員函數為虛函數,則在該類中不能出現和這個成員函數同名并且傳回值、參數個數、參數類型都相同的非虛函數。在以該類為基類的派生類中,也不能出現這種非虛的同名同傳回值同參數個數同參數類型函數。
為什麼虛函數必須是類的成員函數:
虛函數誕生的目的就是為了實作多态,在類外定義虛函數毫無實際用處。
為什麼類的靜态成員函數不能為虛函數:
如果定義為虛函數,那麼它就是動态綁定的,也就是在派生類中可以被覆寫的,這與靜态成員函數的定義(:在記憶體中隻有一份拷貝;通過類名或對象引用通路靜态成員)本身就是相沖突的。
為什麼構造函數不能為虛函數:
因為如果構造函數為虛函數的話,它将在執行期間被構造,而執行期則需要對象已經建立,構造函數所完成的工作就是為了建立合适的對象,是以在沒有建構好的對象上不可能執行多态(虛函數的目的就在于實作多态性)的工作。在繼承體系中,構造的順序就是從基類到派生類,其目的就在于確定對象能夠成功地建構。構造函數同時承擔着虛函數表的建立,如果它本身都是虛函數的話,如何確定vtbl的建構成功呢?
注意:當基類的構造函數内部有虛函數時,會出現什麼情況呢?結果是在構造函數中,虛函數機制不起作用了,調用虛函數如同調用一般的成員函數一樣。當基類的析構函數内部有虛函數時,又如何工作呢?與構造函數相同,隻有“局部”的版本被調用。但是,行為相同,原因是不一樣的。構造函數隻能調用“局部”版本,是因為調用時還沒有派生類版本的資訊。析構函數則是因為派生類版本的資訊已經不可靠了。我們知道,析構函數的調用順序與構造函數相反,是從派生類的析構函數到基類的析構函數。當某個類的析構函數被調用時,其派生類的析構函數已經被調用了,相應的資料也已被丢失,如果再調用虛函數的派生類的版本,就相當于對一些不可靠的資料進行操作,這是非常危險的。是以,在析構函數中,虛函數機制也是不起作用的。
2.虛函數表
對C++ 了解的人都應該知道虛函數(Virtual Function)是通過一張虛函數表(Virtual Table)來實作的。簡稱為V-Table。 在這個表中,主是要一個類的虛函數的位址表,這張表解決了繼承、覆寫的問題,保證其容真實反應實際的函數。這樣,在有虛函數的類的執行個體(注:抽象類即有純虛函數的類不能被執行個體化。)中這個表被配置設定在了這個執行個體的記憶體中(注:一個類的虛函數表是靜态的,也就是說對這個類的每個執行個體,他的虛函數表的是固定的,不會為每個執行個體生成一個相應的虛函數表。),是以,當我們用父類的指針來操作一個子類的時候,這張虛函數表就顯得由為重要了,它就像一個地圖一樣,指明了實際所應該調用的函數。
這裡我們着重看一下這張虛函數表。在C++的标準規格說明書中說到,編譯器必需要保證虛函數表的指針存在于對象執行個體中最前面的位置(這是為了保證正确取到虛函數的偏移量)。 這意味着我們通過對象執行個體的位址得到這張虛函數表,然後就可以周遊其中函數指針,并調用相應的函數。
假設我們有這樣的一個類:
class Base {
public:
virtual void f() { cout << “Base::f” << endl; }
virtual void g() { cout << “Base::g” << endl; }
virtual void h() { cout << “Base::h” << endl; }
};
按照上面的說法,我們可以通過Base的執行個體來得到Base的虛函數表。 下面是實際例程:
{
…
typedef void(*Fun)(void);
Base b;
Fun pFun = NULL;
cout << “虛函數表位址:” << (int*)(&b) << endl;
cout << “虛函數表 — 第一個函數位址:” << (int*)(int)(&b) << endl;
// Invoke the first virtual function
pFun = (Fun)((int)(int)(&b));
pFun();
…
}
實際運作經果如下(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3) :
虛函數表位址:0012FED4
虛函數表 — 第一個函數位址:0044F148
Base::f
通過這個示例,我們可以看到,我們可以通過強行把&b轉成int *,取得虛函數表的位址,然後,再次取址就可以得到第一個虛函數的位址了,也就是Base::f(),這在上面的程式中得到了驗證(把int* 強制轉成了函數指針)。通過這個示例,我們就可以知道如果要調用Base::g()和Base::h(),其代碼如下:
(Fun)*((int*)*(int*)(&b)+0); // Base::f()
(Fun)((int)(int)(&b)+1); // Base::g()
(Fun)((int)(int)(&b)+2); // Base::h()
畫個圖解釋一下。如下所示:

注意:在上面這個圖中,我在虛函數表的最後多加了一個結點,這是虛函數表的結束結點,就像字元串的結束符“/0”一樣,其标志了虛函數表的結束。這個結束标志的值在不同的編譯器下是不同的。
在WinXP+VS2003下,這個值是NULL。
而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下,這個值是如果1,表示還有下一個虛函數表,如果值是0,表示是最後一個虛函數表。
下面,我将分别說明“無覆寫”和“有覆寫”時的子類虛函數表的樣子。沒有覆寫父類的虛函數是毫無意義的。我之是以要講述沒有覆寫的情況,主要目的是為了給一個對比。在比較之下,我們可以更加清楚地知道其内部的具體實作。
(1)、一般繼承(無虛函數覆寫)
下面,再讓我們來看看繼承時的虛函數表是什麼樣的。假設有如下所示的一個繼承關系:
請注意,在這個繼承關系中,子類沒有重寫任何父類的函數。那麼,在派生類的執行個體的虛函數表如下所示:
對于執行個體:Derive d; 的虛函數表如下: (overload(重載) 和 override(重寫),重載就是所謂的名同而簽名不同,重寫就是對子類對虛函數的重新實作。)
我們可以看到下面幾點:
1)虛函數按照其聲明順序放于表中。
2)父類的虛函數在子類的虛函數前面。
(2)、一般繼承(有虛函數覆寫)
覆寫父類的虛函數是很顯然的事情,不然,虛函數就變得毫無意義。下面,我們來看一下,如果子類中有虛函數重載了父類的虛函數,會是一個什麼樣子?假設,我們有下面這樣的一個繼承關系。
為了讓大家看到被繼承過後的效果,在這個類的設計中,我隻覆寫了父類的一個函數:f()。那麼,對于派生類的執行個體的虛函數表會是下面的樣子:
我們從表中可以看到下面幾點,
1)覆寫的f()函數被放到了子類虛函數表中原來父類虛函數的位置。
2)沒有被覆寫的函數依舊。
這樣,我們就可以看到對于下面這樣的程式,
Base *b = new Derive();
b->f();
由b所指的記憶體中的虛函數表(子類的虛函數表)的f()的位置已經被Derive::f()函數位址所取代,于是在實際調用發生時,是Derive::f()被調用了。這就實作了多态。
(3)、多重繼承(無虛函數覆寫)
下面,再讓我們來看看多重繼承中的情況,假設有下面這樣一個類的繼承關系。注意:子類并沒有覆寫父類的函數。
對于子類執行個體中的虛函數表,是下面這個樣子:
我們可以看到:
1) 每個父類都有自己的虛表。
2) 子類的成員函數被放到了第一個父類的表中。(所謂的第一個父類是按照聲明順序來判斷的)
這樣做就是為了解決不同的父類類型的指針指向同一個子類執行個體,而能夠調用到實際的函數。
(4)、多重繼承(有虛函數覆寫)
下面我們再來看看,如果發生虛函數覆寫的情況。
下圖中,我們在子類中覆寫了父類的f()函數。
下面是對于子類執行個體中的虛函數表的圖:
我們可以看見,三個父類虛函數表中的f()的位置被替換成了子類的函數指針。這樣,我們就可以用任一個父類指針來指向子類,并調用子類的f()了。如:
Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()
3.安全性
每次寫C++的文章,總免不了要批判一下C++。這篇文章也不例外。通過上面的講述,相信我們對虛函數表有一個比較細緻的了解了。水可載舟,亦可覆舟。下面,讓我們來看看我們可以用虛函數表來幹點什麼壞事吧。
嘗試1:通過父類型的指針(指向子類對象)通路子類自己的虛函數
我們知道,子類沒有重載父類的虛函數是一件毫無意義的事情。因為多态也是要基于函數重載的。雖然在上面的圖中我們可以看到子類的虛表中有Derive自己的虛函數,但我們根本不可能使用基類的指針來調用子類的自有虛函數:
Base1 *b1 = new Derive();
b1->f1(); //編譯出錯
任何妄圖使用父類指針想調用子類中的未覆寫父類的成員函數的行為都會被編譯器視為非法,是以,這樣的程式根本無法編譯通過。
但在運作時,我們可以通過指針的方式通路虛函數表來達到違反C++語義的行為。
嘗試2:通過父類型的指針(指向子類對象)通路父類的non-public虛函數
另外,如果父類的虛函數是private或是protected的,但這些非public的虛函數同樣會存在于子類虛函數表中,是以我們同樣可以使用通路虛函數表的方式來通路這些non-public的虛函數,這是很容易做到的。
如:
class Base {
private:
virtual void f() { cout << “Base::f” << endl; }
};
class Derive : public Base{
};
typedef void(*Fun)(void);
void main() {
Derive d;
Fun pFun = (Fun)((int)(int)(&d)+0);
pFun();
}
4.總結
C++這門語言是一門Magic的語言,對于程式員來說,我們似乎永遠摸不清楚這門語言背着我們在幹了什麼。需要熟悉這門語言,我們就必需要了解C++裡面的那些東西,需要去了解C++中那些危險的東西。不然,這是一種搬起石頭砸自己腳的程式設計語言。
附錄一:VC中檢視虛函數表
我們可以在VC的IDE環境中的Debug狀态下展開類的執行個體就可以看到虛函數表了(并不是很完整的)
附錄 二:例程
下面是一個關于多重繼承的虛函數表通路的例程:
#include <iostream>
using namespace std;
class Base1 {
public:
virtual void f() { cout << “Base1::f” << endl; }
virtual void g() { cout << “Base1::g” << endl; }
virtual void h() { cout << “Base1::h” << endl; }
};
class Base2 {
public:
virtual void f() { cout << “Base2::f” << endl; }
virtual void g() { cout << “Base2::g” << endl; }
virtual void h() { cout << “Base2::h” << endl; }
};
class Base3 {
public:
virtual void f() { cout << “Base3::f” << endl; }
virtual void g() { cout << “Base3::g” << endl; }
virtual void h() { cout << “Base3::h” << endl; }
};
class Derive : public Base1, public Base2, public Base3 {
public:
virtual void f() { cout << “Derive::f” << endl; }
virtual void g1() { cout << “Derive::g1” << endl; }
};
typedef void(*Fun)(void);
int main()
{
Fun pFun = NULL;
Derive d;
int** pVtab = (int**)&d;
//Base1's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
pFun = (Fun)pVtab[0][0];
pFun();
//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
pFun = (Fun)pVtab[0][1];
pFun();
//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
pFun = (Fun)pVtab[0][2];
pFun();
//Derive's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
pFun = (Fun)pVtab[0][3];
pFun();
//The tail of the vtable
pFun = (Fun)pVtab[0][4];
cout<<pFun<<endl;
//Base2's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
pFun = (Fun)pVtab[1][0];
pFun();
//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
pFun = (Fun)pVtab[1][1];
pFun();
pFun = (Fun)pVtab[1][2];
pFun();
//The tail of the vtable
pFun = (Fun)pVtab[1][3];
cout<<pFun<<endl;
//Base3's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
pFun = (Fun)pVtab[2][0];
pFun();
//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
pFun = (Fun)pVtab[2][1];
pFun();
pFun = (Fun)pVtab[2][2];
pFun();
//The tail of the vtable
pFun = (Fun)pVtab[2][3];
cout<<pFun<<endl;
return 0;
}
以上就是關于C++虛函數及虛函數表的全部解析,希望對大家的學習有所幫助。
=============================================================================================
Linux應用程式、核心、驅動、背景開發交流讨論群(745510310),感興趣的同學可以加群讨論、交流、資料查找等,前進的道路上,你不是一個人奧_。