虛函數表

  虛函數的定義:

  虛函數必須是類的非靜態成員函數(且非構造函數),其訪問權限是public(可以定義爲private or proteceted, 但是對於多態來說,沒有意義。),在基類的類定義中定義虛函數的一般形式:

  virtual 函數返回值類型 虛函數名(形參表)

  { 函數體 }

  虛函數的作用是實現動態聯編,也就是在程序的運行階段動態地選擇合適的成員函數,在定義了虛函數後,

   可以在基類的派生類中對虛函數重新定義(形式也是:virtual 函數返回值類型 虛函數名(形參表){ 函數體 }),在派生類中重新定義的函數應與虛函數具有相同的形參個數和形參類型。以實現統一的接口,不同定義過程。如果在派生類中沒有對虛函數重新定義,則它繼 承其基類的虛函數。當程序發現虛函數名前的關鍵字virtual後,會自動將其作爲動態聯編處理,即在程序運行時動態地選擇合適的成員函數。

  實現動態聯編需要三個條件:

  1、 必須把需要動態聯編的行爲定義爲類的公共屬性的虛函數。

  2、 類之間存在子類型關係,一般表現爲一個類從另一個類公有派生而來。

  3、 必須先使用基類指針指向子類型的對象,然後直接或者間接使用基類指針調用虛函數。

  定義虛函數的限制:

   (1)非類的成員函數不能定義爲虛函數,類的成員函數中靜態成員函數和構造函數也不能定義爲虛函數,但可以將析構函數定義爲虛函數。實際上,優秀的程序 員常常把基類的析構函數定義爲虛函數。因爲,將基類的析構函數定義爲虛函數後,當利用delete刪除一個指向派生類定義的對象指針時,系統會調用相應的 類的析構函數。而不將析構函數定義爲虛函數時,只調用基類的析構函數。

  (2)只需要在聲明函數的類體中使用關鍵字“virtual”將函數聲明爲虛函數,而定義函數時不需要使用關鍵字“virtual”。

  (3)如果聲明瞭某個成員函數爲虛函數,則在該類中不能出現和這個成員函數同名並且返回值、參數個數、參數類型都相同的非虛函數。在以該類爲基類的派生類中,也不能出現這種非虛的同名同返回值同參數個數同參數類型函數。

  爲什麼虛函數必須是類的成員函數:

  虛函數誕生的目的就是爲了實現多態,在類外定義虛函數毫無實際用處。

  爲什麼類的靜態成員函數不能爲虛函數:

  如果定義爲虛函數,那麼它就是動態綁定的,也就是在派生類中可以被覆蓋的,這與靜態成員函數的定義(:在內存中只有一份拷貝;通過類名或對象引用訪問靜態成員)本身就是相矛盾的。

  爲什麼構造函數不能爲虛函數:

  因爲如果構造函數爲虛函數的話,它將在執行期間被構造,而執行期則需要對象已經建立,構造函數所完成的工作 就 是爲了建立合適的對象,因此在沒有構建好的對象上不可能執行多態(虛函數的目的就在於實現多態性)的工作。在繼承體系中,構造的順序就是從基類到派生類, 其目的就在於確保對象能夠成功地構建。構造函數同時承擔着虛函數表的建立,如果它本身都是虛函數的話,如何確保vtbl的構建成功呢?

   注意:當基類的構造函數內部有虛函數時,會出現什麼情況呢?結果是在構造函數中,虛函數機制不起作用了,調用虛函數如同調用一般的成員函數一樣。當基類的 析構函數內部有虛函數時,又如何工作呢?與構造函數相同,只有“局部”的版本被調用。但是,行爲相同,原因是不一樣的。構造函數只能調用“局部”版本,是 因爲調用時還沒有派生類版本的信息。析構函數則是因爲派生類版本的信息已經不可靠了。我們知道,析構函數的調用順序與構造函數相反,是從派生類的析構函數 到基類的析構函數。當某個類的析構函數被調用時,其派生類的析構函數已經被調用了,相應的數據也已被丟失,如果再調用虛函數的派生類的版本,就相當於對一 些不可靠的數據進行操作,這是非常危險的。因此,在析構函數中,虛函數機制也是不起作用的。

  C++中的虛函數的作用主要是實現了多態的 機制。關於多態,簡而言之就是用父類型別的指針指向其子類的實例,然後通過父類的指針調用實際子類的成員函數。這種技術可以讓父類的指針有“多種形態”, 這是一種泛型技術。所謂泛型技術,說白了就是試圖使用不變的代碼(Or 不變的 接口)來實現可變的算法。比如:模板技術,RTTI技術,虛函數技術,要麼是試圖做到在編譯時決議,要麼試圖做到運行時決議。

  虛函數表

  對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,表示是最後一個虛函數表。

  下面,我將分別說明“無覆蓋”和“有覆蓋”時的子類虛函數表的樣子。沒有覆蓋父類的虛函數是毫無意義的。我之所以要講述沒有覆蓋的情況,主要目的是爲了給一個對比。在比較之下,我們可以更加清楚地知道其內部的具體實現。

  一般繼承(無虛函數覆蓋)

  下面,再讓我們來看看繼承時的虛函數表是什麼樣的。假設有如下所示的一個繼承關係:

  請注意,在這個繼承關係中,子類沒有重寫任何父類的函數。那麼,在派生類的實例的虛函數表如下所示:

  對於實例:Derive d; 的虛函數表如下: (overload(重載) 和 override(重寫),重載就是所謂的名同而簽名不同,重寫就是對子類對虛函數的重新實現。)

  我們可以看到下面幾點:

  1)虛函數按照其聲明順序放於表中。

  2)父類的虛函數在子類的虛函數前面。

  一般繼承(有虛函數覆蓋)

  覆蓋父類的虛函數是很顯然的事情,不然,虛函數就變得毫無意義。下面,我們來看一下,如果子類中有虛函數重載了父類的虛函數,會是一個什麼樣子?假設,我們有下面這樣的一個繼承關係。

  爲了讓大家看到被繼承過後的效果,在這個類的設計中,我只覆蓋了父類的一個函數:f()。那麼,對於派生類的實例的虛函數表會是下面的樣子:

  我們從表中可以看到下面幾點,

  1)覆蓋的f()函數被放到了子類虛函數表中原來父類虛函數的位置。

  2)沒有被覆蓋的函數依舊。

  這樣,我們就可以看到對於下面這樣的程序,

  Base *b = new Derive();

  b->f();

  由b所指的內存中的虛函數表(子類的虛函數表)的f()的位置已經被Derive::f()函數地址所取代,於是在實際調用發生時,是Derive::f()被調用了。這就實現了多態。

  多重繼承(無虛函數覆蓋)

  下面,再讓我們來看看多重繼承中的情況,假設有下面這樣一個類的繼承關係。注意:子類並沒有覆蓋父類的函數。

  對於子類實例中的虛函數表,是下面這個樣子:

  我們可以看到:

  1) 每個父類都有自己的虛表。

  2) 子類的成員函數被放到了第一個父類的表中。(所謂的第一個父類是按照聲明順序來判斷的)

  這樣做就是爲了解決不同的父類類型的指針指向同一個子類實例,而能夠調用到實際的函數。

  多重繼承(有虛函數覆蓋)

  下面我們再來看看,如果發生虛函數覆蓋的情況。

  下圖中,我們在子類中覆蓋了父類的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()

  安全性

  每次寫C++的文章,總免不了要批判一下C++。這篇文章也不例外。通過上面的講述,相信我們對虛函數表有一個比較細緻的瞭解了。水可載舟,亦可覆舟。下面,讓我們來看看我們可以用虛函數表來乾點什麼壞事吧。

  一、嘗試:通過父類型的指針(指向子類對象)訪問子類自己的虛函數

  我們知道,子類沒有重載父類的虛函數是一件毫無意義的事情。因爲多態也是要基於函數重載的。雖然在上面的圖中我們可以看到子類的虛表中有Derive自己的虛函數,但我們根本不可能使用基類的指針來調用子類的自有虛函數:

  Base1 *b1 = new Derive();

  b1->f1(); //編譯出錯

  任何妄圖使用父類指針想調用子類中的未覆蓋父類的成員函數的行爲都會被編譯器視爲非法,所以,這樣的程序根本無法編譯通過。

  但在運行時,我們可以通過指針的方式訪問虛函數表來達到違反C++語義的行爲。

  二、嘗試:通過父類型的指針(指向子類對象)訪問父類的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();
  }

  結束語

  C++這門語言是一門Magic的語言,對於程序員來說,我們似乎永遠摸不清楚這門語言揹着我們在幹了什麼。需要熟悉這門語言,我們就必需要了解C++裏面的那些東西,需要去了解C++中那些危險的東西。不然,這是一種搬起石頭砸自己腳的編程語言。

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章