C++面向對象之多態的實現和應用詳解

前言

本文主要給大家介紹的是關于C++面向對象之多態的實現和應用的相關內容，分享出來供大家參考學習，下面話不多說了，來一起看看詳細的介紹吧。

多態

大家應該都聽過C++三大特性之一多態，那么什么多態呢？多態有什么用？通俗一點來講->

多態性可以簡單地概括為“一個接口，多種方法”，程序在運行時才決定調用的函數，它是面向對象編程領域的核心概念。當多態應用形參類型的時候，可以接受更多的類型。當多態用于返回值類型的時候，可以返回更多類型的數據。多態可以讓你的代碼擁有更好的擴展性。

多態分兩種分別為靜態多態和動態多態：

• 靜態多態：靜態多態就是重載，因為是在編譯期決議確定，所以稱為靜態多態。
• 動態多態：動態多態就是通過繼承重寫基類的虛函數實現的多態，因為是在運行時決議確定，所以稱為動態多態。

而我們主要今天來看動態多態的問題。比如我們來看下面的代碼，就是簡單的動態多態：

class Person 
{ 
public: 
 virtual void BuyTickets() 
 { 
 cout << " 買票" << endl; 
 } 
 
protected: 
 string _name; // 姓名 
}; 
 
class Student : public Person 
{ 
public: 
 virtual void BuyTickets() 
 { 
 cout << " 買票-半價 " << endl; 
 } 
 
protected: 
 int _num; //學號 
}; 
 
void Fun(Person& p) 
{ 
 p.BuyTickets(); 
} 
 
void Test() 
{ 
 Person p; 
 Student s; 
 Fun(p); 
 Fun(s); 
} 
int main() 
{ 
 Test(); 
 system("pause"); 
 return 0; 
} 

構成多態的四大條件: (缺一不可)

      1.不在同一作用域（分別在父類和子類）

      2.函數名相等/參數相等/返回值相同/（協變除外）

      3.基類函數必須有virtual關鍵字

      4.訪問修飾符可以不同

具體多態是如何實現的？？ 這里我們先從虛函數表這個知識點講起，每一個帶有虛函數的對象都會有一個虛函數表，虛函數表里存的是函數指針，然后調用的時候，指針回去虛函數表里面訪問查找。對于這個知識點我的另外一個博客很詳細的講解到，大家可以先看看這個:https://www.jb51.net/article/123308.htm

然后我們來了解一下重寫是什么東西?

重寫的過程

如果這塊還是不理解，你可以看我專門寫虛函數那片博客，仔細看一定會看懂的.

接下來多態的原理我們就明白了吧. 發生重寫之后，下一次父類指針指向我調用fun()函數的時候，它調用到的就是子類的fun(）函數，其實多態就是這么簡單，只要理解重寫就理解多態. 虛函數表是我們必須掌握的一個知識點.

通過匯編來分析多態的實現

好了，我們繼續往下走，剛剛我們從虛函數表這方面，探究了多態的實現，現在我們再從匯編的角度再來看多態是如何實現的。

我們來看一段新的代碼：

class Person 
{ 
public: 
 virtual void BuyTickets() 
 { 
 cout << " 買票" << endl; 
 } 
 
protected: 
 string _name; // 姓名 
}; 
 
class Student : public Person 
{ 
public: 
 virtual void BuyTickets() 
 { 
 cout << " 買票-半價 " << endl; 
 } 
 
protected: 
 int _num; //學號 
}; 
void Fun(Person& p) 
{ 
 p.BuyTickets(); 
} 
 
void Test() 
{ 
 Person p; 
 Student q; 
 Person* ptr = &q; 
 p.BuyTickets(); 
 ptr->BuyTickets(); 
} 
int main() 
{ 
 Test(); 
 system("pause"); 
 return 0; 
} 

打開我們的反匯編窗口：

這里我們看到用指向子類的父類類型指針調用BuyTickets函數和直接用對象調用匯編代碼相差巨大，一個只有2句話，一個那么長，這是因為在發生多態時當你用指針調用時，系統不知道你要用哪一個函數，因為這里有多態現象，所以系統只能老實的去虛函數表里查找，所以才會有這么多的代碼，接下來我們來解釋一下這些匯編，來看看系統是調用虛表的。

這里我們就關心到了那四個紅色的句子，可以看到這里一直都是想講虛函數表的地址傳給系統，然后再傳this指針，就可以調用哪個函數了。藍色的就是一個小知識~ 知道有這么個東西就好了.

虛函數是在基類中定義的，目的是不確定它的派生類的具體行為。例：

1. 定義一個基類：class Animal//動物。它的函數為breathe()//呼吸。
2. 再定義一個類class Fish//魚 。它的函數也為breathe()
3. 再定義一個類class Sheep //羊。它的函數也為breathe()
4. 為了簡化代碼，將Fish,Sheep定義成基類Animal的派生類。

然而Fish與Sheep的breathe不一樣，一個是在水中通過水來呼吸，一個是直接呼吸空氣。所以基類不能確定該如何定義breathe，所以在基類中只定義了一個virtual breathe,它是一個空的虛函數。具本的函數在子類中分別定義。程序一般運行時，找到類，如果它有基類，再找它的基類，最后運行的是基類中的函數，這時，它在基類中找到的是virtual標識的函數，它就會再回到子類中找同名函數。派生類也叫子類。基類也叫父類。這就是虛函數的產生，和類的多態性（breathe）的體現。

 一般情況下（沒有涉及virtual函數），當我們用一個指針/引用調用一個函數的時候，被調用的函數是取決于這個指針/引用的類型。即如果這個指針/引用是基類對象的指針/引用就調用基類的方法；如果指針/引用是派生類對象的指針/引用就調用派生類的方法，當然如果派生類中沒有此方法，就會向上到基類里面去尋找相應的方法。這些調用在編譯階段就確定了。

當設計到多態性的時候，采用了虛函數和動態綁定，此時的調用就不會在編譯時候確定而是在運行時確定。不在單獨考慮指針/引用的類型而是看指針/引用的對象的類型來判斷函數的調用，根據對象中虛指針指向的虛表中的函數的地址來確定調用哪個函數。

現在我們來一個小練習：

#include<iostream> 
#include<Windows.h> 
using namespace std; 
 
class A 
{ 
public: 
 void foo() 
 { 
 printf("1\n"); 
 } 
 virtual void fun() 
 { 
 printf("2\n"); 
 } 
}; 
class B : public A 
{ 
public: 
 void foo() 
 { 
 printf("3\n"); 
 } 
 void fun() 
 { 
 printf("4\n"); 
 } 
}; 
int main(void) 
{ 
 A a; 
 B b; 
 A *p = &a; 
 p->foo(); 
 p->fun(); 
 p = &b; 
 p->foo(); 
 p->fun(); 
 system("pause"); 
 return 0; 
} 

這道題的運行結果分別是 1 2 1 4,，現在我們來分析為什么？

首先當一個父類類型指針指向父類時，我們應該知道這里沒有多態，該怎么調用就怎么調用，所以調用了父類里面的foo函數和fun函數。現在我們重點來看后面這個，現在B繼承了A，我們先判斷這里是否有多態現象（1.父類和子類是否有重寫現象 2.是否有父類類型的指針指向子類），現在很明顯子類的fun函數重寫了父類的fun函數，所以現在p->fun()調用的就是子類的fun函數，然后foo函數，根本不構成多態，所以這里指針類型是什么那個對象就按那個對象調用。總結一下當你碰到關于繼承的問題，首先判斷它里面是否有多態現象，如果沒有那就根據指針/引用類型調用。如果有多態的話，一定要注意根據指針/引用的指向對象判斷。

總結

以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對億速云的支持。