掌握了多態的特性，寫英雄聯盟的程式碼更少啦！

• 2020 年 3 月 31 日
• 筆記

— 1 —

虛函數和多態

|| 01 虛函數

• 在類的定義中，前面有 virtual 關鍵字的成員函數稱為虛函數；
• virtual 關鍵字只用在類定義里的函數聲明中，寫函數體時不用。

class Base  {      virtual int Fun() ; // 虛函數  };    int Base::Fun() // virtual 欄位不用在函數體時定義  {  }

— —

|| 02 多態的表現形式一

• 「派生類的指針」可以賦給「基類指針」；
• 通過基類指針調用基類和派生類中的同名「虛函數」時:
  1. 若該指針指向一個基類的對象，那麼被調用是 基類的虛函數；
  2. 若該指針指向一個派生類的對象，那麼被調用 的是派生類的虛函數。

這種機制就叫做「多態」，說白點就是調用哪個虛函數，取決於指針對象指向哪種類型的對象。

上例子中的 p 指針對象指向的是 CSon 類對象，所以 p->Fun() 調用的是 CSon 類里的 Fun 成員函數。

— —

|| 03 多態的表現形式二

• 派生類的對象可以賦給基類「引用」
• 通過基類引用調用基類和派生類中的同名「虛函數」時:
  1. 若該引用引用的是一個基類的對象，那麼被調 用是基類的虛函數；
  2. 若該引用引用的是一個派生類的對象，那麼被 調用的是派生類的虛函數。

這種機制也叫做「多態」，說白點就是調用哪個虛函數，取決於引用的對象是哪種類型的對象。

上例子中的 r 引用的對象是 CSon 類對象，所以 r.Fun() 調用的是 CSon 類里的 Fun 成員函數。

— —

|| 04 多態的簡單例子

A類、B類、E類、D類的關係如下圖：

調用使用：

輸出結果：

A::Print  B::Print  D::Print  E::Print

— —

|| 05 多態的作用

在面向對象的程式設計中使用「多態」，能夠增強程式的可擴充性，即程式需要修改或增加功能的時候，需要改動和增加的程式碼較少。

— 2 —

LOL 英雄聯盟遊戲

|| 01 需求分析

下面我們用設計 LOL 英雄聯盟遊戲的英雄的例子，說明多態為什麼可以在修改或增加功能的時候，可以較少的改動程式碼。

LOL 英雄聯盟是 5v5 競技遊戲，遊戲中有很多英雄，每種英雄都有一個「類」與之對應，每個英雄就是一個「對象」。

英雄之間能夠互相攻擊，攻擊敵人和被攻擊時都有相應的動作，動作是通過對象的成員函數實現的。

下面挑了五個英雄：

• 探險家 CEzreal
• 蓋樓 CGaren
• 盲僧 CLeesin
• 無極劍聖 CYi
• 瑞茲 CRyze

基本思路：

1. 為每個英雄類編寫 Attack、FightBack 和 Hurted 成員函數：

• Attack 函數表示攻擊動作；
• FightBack 函數表示反擊動作；
• Hurted 函數表示減少自身生命值，並表現受傷動作。

1. 設置基類CHero，每個英雄類都繼承此基類

— —

|| 02 非多態的實現方式

有 n 種英雄，CYi 類中就會有 n 個 Attack 成員函數，以及 n 個 FightBack 成員函數。對於其他類也如此。

如果遊戲版本升級，增加了新的英雄寒冰艾希 CAshe，則程式改動較大。所有的類都需要增加兩個成員函數:

void Attack(CAshe * pAshe);  void FightBack(CAshe * pAshe);

這樣工作量是非常大的！！非常的不人性，所以這種設計方式是非常的不好！

— —

|| 03 多態的實現方式

用多態的方式去實現，就能得知多態的優勢了，那麼上面的栗子改成多態的方式如下：

如果增加了新的英雄寒冰艾希 CAshe，只需要編寫新類CAshe，不再需要在已有的類里專門為新英雄增加：

void Attack( CAshe * pAshe);  void FightBack(CAshe * pAshe);

所以已有的類可以原封不動，那麼使用多態的特性新增英雄的時候，可見改動量是非常少的。

多態使用方式：

void CYi::Attack(CHero * pHero)  {      pHero->Hurted(m_nPower); // 多態      pHero->FightBack(this);  // 多態  }    CYi yi;  CGaren garen;  CLeesin leesin;  CEzreal ezreal;    yi.Attack( &garen );  //(1)  yi.Attack( &leesin ); //(2)  yi.Attack( &ezreal ); //(3)

根據多態的規則，上面的(1)，(2)，(3)進入到 CYi::Attack 函數後

分別調用：

CGaren::Hurted  CLeesin::Hurted  CEzreal::Hurted

— 3 —

多態的又一例子

出一道題考考大家，看大家是否理解到了多態的特性，下面的程式碼，pBase->fun1()輸出結果是什麼呢？

是不是大家覺得 pBase 指針對象雖然指向的是派生類對象，但是派生類里沒有 fun1 成員函數，則就調用基類的 fun1 成員函數，Base::fun1() 里又會調用基類的 fun2 成員函數，所以輸出結果是Base::fun2() ？

假設我把上面的程式碼轉換一下， 大家還覺得輸出的是 Base::fun2() 嗎？

class Base  {  public:      void fun1()      {          this->fun2();  // this是基類指針，fun2是虛函數，所以是多態      }  }

this 指針的作用就是指向成員函數所作用的對象， 所以非靜態成員函數中可以直接使用 this 來代表指向該函數作用的對象的指針。

pBase 指針對象指向的是派生類對象，派生類里沒有 fun1 成員函數，所以就會調用基類的 fun1 成員函數，在Base::fun1() 成員函數體里執行 this->fun2() 時，實際上指向的是派生類對象的 fun2 成員函數。

所以正確的輸出結果是：

Derived:fun2()

所以我們需要注意：

在非構造函數，非析構函數的成員函數中調用「虛函數」，也是多態!!!

— 4 —

構造函數和析構函數

存在多態嗎？

在構造函數和析構函數中調用「虛函數」，不是多態。

編譯時即可確定，調用的函數是自己的類或基類中定義的函數，不會等到運行時才決定調用自己的還是派生類的函數。

我們看如下的程式碼例子，來說明：

輸出結果：

hello from son  // 構造son對象時執行的構造函數  hello from son  // 多態  bye from father // son對象析構時，由於CSon類沒有bye成員函數，所以調用了基類的bye成員函數

— 5 —

多態的實現原理

「多態」的關鍵在於通過基類指針或引用調用一個虛函數時，編譯時不能確定到底調用的是基類還是派生類的函數，運行時才能確定。

我們用 sizeof 來運算有有虛函數的類和沒虛函數的類的大小，會是什麼結果呢？

class A  {  public:      int i;      virtual void Print() { } // 虛函數  };    class B  {  public:      int n;      void Print() { }  };    int main()  {      cout << sizeof(A) << ","<< sizeof(B);      return 0;  }

在 64 位機子，執行的結果：

16,4

從上面的結果，可以發現有虛函數的類，多出了 8 個位元組，在 64 位機子上指針類型大小正好是 8 個位元組，這多出 8 個位元組的指針有什麼作用呢？

— —

|| 01 虛函數表

每一個有「虛函數」的類（或有虛函數的類的派生類）都有一個「虛函數表」，該類的任何對象中都放著虛函數表的指針。「虛函數表」中列出了該類的「虛函數」地址。

多出來的 8 個位元組就是用來放「虛函數表」的地址。

// 基類  class Base  {  public:      int i;      virtual void Print() { } // 虛函數  };    // 派生類  class Derived : public Base  {  public:      int n;      virtual void Print() { } // 虛函數  };

上面 Derived 類繼承了 Base類，兩個類都有「虛函數」，那麼它「虛函數表」的形式可以理解成下圖：

多態的函數調用語句被編譯成一系列根據基類指針所指向的（或基類引用所引用的）對象中存放的虛函數表的地址，在虛函數表中查找虛函數地址，並調用虛函數的指令。

— —

|| 02 證明虛函數表指針的作用

在上面我們用 sizeof 運算符計算了有虛函數的類的大小，發現是多出了 8 位元組大小（64位系統），這多出來的 8 個位元組就是指向「虛函數表的指針」。「虛函數表」中列出了該類的「虛函數」地址。

下面用程式碼的例子，來證明「虛函數表指針」的作用：

輸出結果：

B::Func  A::Func

• 第 25-26 行程式碼中的 pa 指針指向的是 B 類對象，所以 pa->Func() 調用的是 B 類對象的虛函數 Func()，輸出內容是 B::Func ；
• 第 29-30 行程式碼的目的是把 A 類的頭 8 個位元組的「虛函數表指針」存放到 p1 指針和把 B 類的頭 8 個位元組的「虛函數表指針」存放到 p2 指針；
• 第 32 行程式碼目的是把 A 類的「虛函數表指針」 賦值給 B 類的「虛函數表指針」，所以相當於把 B 類的「虛函數表指針」 替換 成了 A 類的「虛函數表指針」；
• 由於第 32 行的作用，把 B 類的「虛函數表指針」 替換 成了 A 類的「虛函數表指針」，所以第 33 行調用的是 A 類的虛函數 Func()，輸出內容是 A::Func

通過上述的程式碼和講解，可以有效的證明了「虛函數表的指針」的作用，「虛函數表的指針」指向的是「虛函數表」，「虛函數表」里存放的是類里的「虛函數」地址，那麼在調用過程中，就能實現多態的特性。

— 5 —

虛析構函數

析構函數是在刪除對象或退出程式的時候，自動調用的函數，其目的是做一些資源釋放。

那麼在多態的情景下，通過基類的指針刪除派生類對象時，通常情況下只調用基類的析構函數，這就會存在派生類對象的析構函數沒有調用到，存在資源泄露的情況。

看如下的例子：

// 基類  class A  {  public:      A()  // 構造函數      {          cout << "construct A" << endl;      }        ~A() // 析構函數      {          cout << "Destructor A" << endl;      }  };    // 派生類  class B : public A  {  public:      B()  // 構造函數      {          cout << "construct B" << endl;      }        ~B()// 析構函數      {          cout << "Destructor B" << endl;      }  };    int main()  {      A *pa = new B();      delete pa;        return 0;  }

輸出結果：

construct A  construct B  Destructor A

從上面的輸出結果可以看到，在刪除 pa指針對象時，B 類的析構函數沒有被調用。

解決辦法：把基類的析構函數聲明為virtual

• 派生類的析構函數可以 virtual 不進行聲明；
• 通過基類的指針刪除派生類對象時，首先調用派生類的析構函數，然後調用基類的析構函數，還是遵循「先構造，後虛構」的規則。

將上述的程式碼中的基類的析構函數，定義成「虛析構函數」：

// 基類  class A  {  public:      A()      {          cout << "construct A" << endl;      }        virtual ~A() // 虛析構函數      {          cout << "Destructor A" << endl;      }  };

輸出結果：

construct A  construct B  Destructor B  Destructor A

所以要養成好習慣:

• 一個類如果定義了虛函數，則應該將析構函數也定義成虛函數;
• 或者，一個類打算作為基類使用，也應該將析構函數定義成虛函數。
• 注意：構造函數不能定義成虛構造函數。

— 6 —

純虛函數和抽象類

純虛函數：沒有函數體的虛函數

class A  {  public:      virtual void Print() = 0 ; //純虛函數  private:      int a;  };

包含純虛函數的類叫抽象類

• 抽象類只能作為基類來派生新類使用，不能創建抽象類的對象
• 抽象類的指針和引用可以指向由抽象類派生出來的類的對象

A a;         // 錯，A 是抽象類，不能創建對象  A * pa ;     // ok,可以定義抽象類的指針和引用  pa = new A ; // 錯誤, A 是抽象類，不能創建對象