前言

本文主要給大家介紹了關于C++中繼承與多態(tài)的基礎虛函數(shù)類的相關內容，分享出來供大家參考學習，下面話不多說了，來一起看看詳細的介紹吧。

虛函數(shù)類

繼承中我們經常提到虛擬繼承，現(xiàn)在我們來探究這種的虛函數(shù)，虛函數(shù)類的成員函數(shù)前面加virtual關鍵字，則這個成員函數(shù)稱為虛函數(shù)，不要小看這個虛函數(shù)，他可以解決繼承中許多棘手的問題，而對于多態(tài)那他更重要了，沒有它就沒有多態(tài)，所以這個知識點非常重要，以及后面介紹的虛函數(shù)表都極其重要，一定要認真的理解~ 現(xiàn)在開始概念虛函數(shù)就又引出一個概念，那就是重寫（覆蓋），當在子類的定義了一個與父類完全相同的虛函數(shù)時，則稱子類的這個函數(shù)重寫（也稱覆蓋）了父類的這個虛函數(shù)。這里先提一下虛函數(shù)表，后面會講到的，重寫就是將子類里面的虛函數(shù)表里的被重寫父類的函數(shù)地址全都改成子類函數(shù)的地址。

純虛函數(shù)

在成員函數(shù)的形參后面寫上=0，則成員函數(shù)為純虛函數(shù)。包含純虛函數(shù)的類叫做抽象類（也叫接口類）

抽象類不能實例化出對象。純虛函數(shù)在派生類中重新定義以后，派生類才能實例化出對象。

看一個例子：

class Person 
{ 
  virtual void Display () = 0; // 純虛函數(shù) 
protected : 
  string _name ;   // 姓名 
}; 
 
class Student : public Person 
{}; 

先總結一下概念：

1.派生類重寫基類的虛函數(shù)實現(xiàn)多態(tài)，要求函數(shù)名、參數(shù)列表、返回值完全相同。（協(xié)變除外）

2.基類中定義了虛函數(shù)，在派生類中該函數(shù)始終保持虛函數(shù)的特性。

3.只有類的成員函數(shù)才能定義為虛函數(shù)。

4.靜態(tài)成員函數(shù)不能定義為虛函數(shù)。

5.如果在類外定義虛函數(shù)，只能在聲明函數(shù)時加virtual，類外定義函數(shù)時不能加virtual。

6.不要在構造函數(shù)和析構函數(shù)里面調用虛函數(shù)，在構造函數(shù)和析構函數(shù)中，對象是不完整的，可能會發(fā)生未定義的行為。

7.最好把基類的析構函數(shù)聲明為虛函數(shù)。（why？另外析構函數(shù)比較特殊，因為派生類的析構函數(shù)跟基類的析構函數(shù)名稱不一樣，但是構成覆蓋，這里是因為編譯器做了特殊處理）

8.構造函數(shù)不能為虛函數(shù)，雖然可以將operator=定義為虛函數(shù)，但是最好不要將operator=定義為虛函數(shù)，因為容易使用時容易引起混淆.

上面概念大家可能都會問一句為什么要這樣? 這些內容在接下來的知識里都能找到答案~ 好了那么我們今天的主角虛函數(shù)登場!!!!

何為虛函數(shù)表，我們寫一個程序，調一個監(jiān)視窗口就知道了。

下面是一個有虛函數(shù)的類：

#include<iostream> 
#include<windows.h> 
using namespacestd; 
 
class Base 
{ 
public: 
   virtual void func1() 
   {} 
 
   virtual void func2() 
   {} 
 
private: 
   inta; 
}; 
 
void Test1() 
{ 
   Base b1; 
} 
 
int main() 
 
{ 
   Test1(); 
   system("pause"); 
   return0; 
} 

我們現(xiàn)在點開b1的監(jiān)視窗口

這里面有一個_vfptr，而這個_vfptr指向的東西就是我們的主角，虛函數(shù)表。一會大家就知道了，無論是單繼承還是多繼承甚至于我們的菱形繼承虛函數(shù)表都會有不同的形態(tài)，虛函數(shù)表是一個很有趣的東西。

我們來研究一下單繼承的內存格局

仔細看下面代碼：

#include<iostream> 
#include<windows.h> 
using namespace std; 
 
 
class Base 
{ 
public: 
   virtual void func1() 
   { 
     cout<< "Base::func1"<< endl; 
   } 
 
   virtual void func2() 
   { 
     cout<< "Base::func2"<< endl; 
   } 
 
private: 
   inta; 
}; 
 
class Derive:public Base 
{ 
public: 
   virtual void func1() 
   { 
     cout<< "Derive::func1"<< endl; 
   } 
 
   virtual void func3() 
   { 
     cout<< "Derive::func3"<< endl; 
   } 
 
   virtual void func4() 
   { 
     cout<< "Derive::func4"<< endl; 
   } 
 
private: 
   int b; 
}; 

對于Derive類來說，我們覺得它的虛表里會有什么？

首先子類的fun1()重寫了父類的fun1() ，虛表里存的是子類的fun1() ,接下來父類的fun2() ,子類的fun3() , fun4()都是虛函數(shù)，所以虛表里會有4個元素，分別為子類的fun1() ,父類fun2() ,子類fun3() ，子類fun4() 。然后我們調出監(jiān)視窗口看我們想的到底對不對呢？

我預計應該是看到fun1() ,fun2() ,fun3() ,fun4()的虛函數(shù)表，但是呢這里監(jiān)視窗口只有兩個fun1() , fun2() ，難道我們錯了？？？？

這里并不是這樣的，只有自己靠得住，我覺得這里的編譯器有問題，那我們就得自己探索一下了。 但是在探索之前我們必須來實現(xiàn)一個可以打印虛函數(shù)表的函數(shù)。

typedef void(*FUNC)(void); 
void PrintVTable(int* VTable) 
{ 
   cout<< " 虛表地址"<<VTable<< endl; 
 
   for(inti = 0;VTable[i] != 0; ++i) 
   { 
     printf(" 第%d個虛函數(shù)地址 :0X%x,->", i,VTable[i]); 
     FUNC f = (FUNC)VTable[i]; 
     f(); 
   } 
 
   cout<< endl; 
} 
 
 
int main() 
{ 
   Derive d1; 
   PrintVTable((int*)(*(int*)(&d1))); 
   system("pause"); 
   return0; 
} 

下圖來說一下他的緣由：

我們來使用這個函數(shù)，該函數(shù)代碼如下:

//單繼承 
class Base 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Base::func1" << endl; 
 } 
 
 virtual void func2() 
 { 
  cout << "Base::func2" << endl; 
 } 
 
private: 
 int a; 
}; 
 
class Derive :public Base 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Derive::func1" << endl; 
 } 
 
 virtual void func3() 
 { 
  cout << "Derive::func3" << endl; 
 } 
 
 virtual void func4() 
 { 
  cout << "Derive::func4" << endl; 
 } 
 
private: 
 int b; 
}; 
typedef void(*FUNC)(void); 
void PrintVTable(int* VTable) 
{ 
   cout<< " 虛表地址"<<VTable<< endl; 
  
   for(inti = 0;VTable[i] != 0; ++i) 
   { 
     printf(" 第%d個虛函數(shù)地址 :0X%x,->", i,VTable[i]); 
     FUNC f = (FUNC)VTable[i]; 
     f(); 
   } 
  
   cout<< endl; 
} 
  
  
int main() 
{ 
   Derive d1; 
   PrintVTable((int*)(*(int*)(&d1))); //重點 
   system("pause"); 
   return0; 
} 

這里我就要講講這個傳參了，注意這里的傳參不好理解，應當細細的"品味".

PrintVTable((int*)(*(int*)(&d1)));

首先我們肯定要拿到d1的首地址，把它強轉成int*，讓他讀取到前4個字節(jié)的內容（也就是指向虛表的地址），再然后對那個地址解引用，我們已經拿到虛表的首地址的內容(虛表里面存儲的第一個函數(shù)的地址)了，但是此時這個變量的類型解引用后是int，不能夠傳入函數(shù)，所以我們再對他進行一個int*的強制類型轉換，這樣我們就傳入參數(shù)了，開始函數(shù)執(zhí)行了，我們一切都是在可控的情況下使用強轉，使用強轉你必須要特別清楚的知道內存的分布結構。

最后我們來看看輸出結果：

到底打印的對不對呢？ 我們驗證一下： 

這里我們通過&d1的首地址找到虛表的地址，然后訪問地址查看虛表的內容，驗證我們自己寫的這個函數(shù)是正確的。（這里VS還有一個bug，當你第一次打印虛表時程序可能會崩潰，不要擔心你重新生成解決方案，再運行一次就可以了。因為當你第一次打印是你虛表最后一個地方可能沒有放0，所以你就有可能停不下來然后崩潰。）我們可以看到d1的虛表并不是監(jiān)視器里面打印的那個樣子的，所以有時候VS也會有bug，不要太相信別人，還是自己靠得住。哈哈哈，臭美一下~

我們來研究一下多繼承的內存格局

探究完了單繼承，我們來看看多繼承，我們還是通過代碼調試的方法來探究對象模型

看如下代碼：

class Base1 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Base1::func1" << endl; 
 } 
 
 virtual void func2() 
 { 
  cout << "Base1::func2" << endl; 
 } 
 
private: 
 int b1; 
}; 
 
class Base2 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Base2::func1" << endl; 
 } 
 
 virtual void func2() 
 { 
  cout << "Base2::func2" << endl; 
 } 
 
private: 
 int b2; 
}; 
 
 
class Derive : public Base1, public Base2 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Derive::func1" << endl; 
 } 
 
 virtual void func3() 
 { 
  cout << "Derive::func3" << endl; 
 } 
 
private: 
 int d1; 
}; 
 
typedef void(*FUNC) (); 
void PrintVTable(int* VTable) 
{ 
 cout << " 虛表地址>" << VTable << endl; 
 
 for (int i = 0; VTable[i] != 0; ++i) 
 { 
  printf(" 第%d個虛函數(shù)地址 :0X%x,->", i, VTable[i]); 
  FUNC f = (FUNC)VTable[i]; 
  f(); 
 } 
 cout << endl; 
} 
 
 
void Test1() 
{ 
 Derive d1; 
 //Base2虛函數(shù)表在對象Base1后面 
 int* VTable = (int*)(*(int*)&d1); 
 PrintVTable(VTable); 
 int* VTable2 = (int *)(*((int*)&d1 + sizeof (Base1) / 4)); 
 PrintVTable(VTable2); 
} 
int main() 
{ 
 Test1(); 
 system("pause"); 
 return 0; 
} 

現(xiàn)在我們現(xiàn)在知道會有兩個虛函數(shù)表，分別是Base1和Base2的虛函數(shù)表，但是呢！我們的子類里的fun3()函數(shù)怎么辦？它是放在Base1里還是Base2里還是自己開辟一個虛函數(shù)表呢？我們先調一下監(jiān)視窗口：

監(jiān)視窗口又不靠譜了。。。。完全沒有找到fun3().那我們直接看打印出來的虛函數(shù)表。

現(xiàn)在很清楚了，fun3()在Base1的虛函數(shù)表中，而Base1是先繼承的類，好了現(xiàn)在我們記住這個結論，當涉及多繼承時，子類的虛函數(shù)會存在先繼承的那個類的虛函數(shù)表里。記住了！

我們現(xiàn)在來看多繼承的對象模型：

現(xiàn)在我們來結束一下上面我列的那么多概念現(xiàn)在我來逐一的解釋為什么要這樣.

1.為什么靜態(tài)成員函數(shù)不能定義為虛函數(shù)?

因為靜態(tài)成員函數(shù)它是一個大家共享的一個資源，但是這個靜態(tài)成員函數(shù)沒有this指針，而且虛函數(shù)變只有對象才能能調到，但是靜態(tài)成員函數(shù)不需要對象就可以調用，所以這里是有沖突的.

2.為什么不要在構造函數(shù)和析構函數(shù)里面調用虛函數(shù)？

構造函數(shù)當中不適合用虛函數(shù)的原因是:在構造對象的過程中，還沒有為“虛函數(shù)表”分配內存。所以，這個調用也是違背先實例化后調用的準則析構函數(shù)當中不適用虛函數(shù)的原因是：一般析構函數(shù)先析構子類的，當你在父類中調用一個重寫的fun()函數(shù)，虛函數(shù)表里面就是子類的fun()函數(shù)，這時候已經子類已經析構了，當你調用的時候就會調用不到.

現(xiàn)在我在寫最后一個知識點，為什么盡量最好把基類的析構函數(shù)聲明為虛函數(shù)？？

現(xiàn)在我們再來寫一個例子，我們都知道平時正常的實例化對象然后再釋放是沒有一點問題的，但是現(xiàn)在我這里舉一個特例：

我們都知道父類的指針可以指向子類，現(xiàn)在呢我們我們用一個父類的指針new一個子類的對象。

//多態(tài) 析構函數(shù) 
class Base 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Base::func1" << endl; 
 } 
 
 virtual void func2() 
 { 
  cout << "Base::func2" << endl; 
 } 
 
 virtual ~Base() 
 { 
  cout << "~Base" << endl; 
 } 
 
private: 
 int a; 
}; 
 
class Derive :public Base 
{ 
public: 
 virtual void func1() 
 { 
  cout << "Derive::func1" << endl; 
 } 
 virtual ~Derive() 
 { 
  cout << "~Derive"<< endl; 
 } 
private: 
 int b; 
}; 
 
void Test1() 
{ 
 Base* q = new Derive; 
 delete q; 
} 
int main() 
{ 
 Test1(); 
 system("pause"); 
 return 0; 
} 

這里面可能會有下一篇要說的多態(tài)，所以可能理解起來會費勁一點。

注意這里我先讓父類的析構函數(shù)不為虛函數(shù)(去掉virtual)，我們看看輸出結果：

這里它沒有調用子類的析構函數(shù)，因為他是一個父類類型指針，所以它只能調用父類的析構函數(shù)，無權訪問子類的析構函數(shù)，這種調用方法會導致內存泄漏，所以這里就是有缺陷的，但是C++是不會允許自己有缺陷，他就會想辦法解決這個問題，這里就運用到了我們下次要講的多態(tài)。現(xiàn)在我們讓加上為父類析構函數(shù)加上virtual，讓它變回虛函數(shù)，我們再運行一次程序的：

誒！ 子類的虛函數(shù)又被調用了，這里發(fā)生了什么呢？？  來我們老方法打開監(jiān)視窗口。

剛剛這種情況就是多態(tài)，多態(tài)性可以簡單地概括為“一個接口，多種方法”，程序在運行時才決定調用的函數(shù)，它是面向對象編程領域的核心概念。這個我們下一個博客專門會總結多態(tài).

當然虛函數(shù)的知識點遠遠沒有這么一點，這里可能只是冰山一角，比如說菱形繼承的虛函數(shù)表是什么樣？然后菱形虛擬繼承又是什么樣子呢？ 這些等我總結一下會專門寫一個博客來討論菱形繼承。虛函數(shù)表我們應該已經知道是什么東西了，也知道單繼承和多繼承中它的應用，這些應該就足夠了，這些其實都是都是為你讓你更好的理解繼承和多態(tài)，當然你一定到分清楚重寫，重定義，重載的他們分別的含義是什么. 這一塊可能有點繞，但是我們必須要掌握.

總結

以上就是對虛函數(shù)的一點簡單見解，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對我們的支持。