2. 程式人生 > >【C++】——多型（下）再探虛表&不同繼承下帶有虛擬函式的物件模型

【C++】——多型（下）再探虛表&不同繼承下帶有虛擬函式的物件模型

阿新 • • 發佈：2019-01-14

一、虛擬函式

1、概念：簡單地說，那些被virtual關鍵字修飾的成員函式，就是虛擬函式。虛擬函式的作用，用專業術語來解釋就是實現多型。
2、程式碼示例：

class Base
{
public:
    virtual void TestFunc1()
    {
        cout << "Base::TestFunc1()" << endl;
    }
    virtual void TestFunc2()
    {
        cout << "Base::TestFunc2()" << endl;
    }
    virtual
 
 void TestFunc3()
    {
        cout << "Base::TestFunc3()" << endl;
    }

    int _b;
};

typedef void(*PVTF)();
void PrintVTF(Base& b)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
int
 
 main()
{
    cout << sizeof(Base) << endl;//8
    Base b;
    b._b = 1;

    PrintVTF(b);
    return 0;
}

上面列印虛擬函式的函式裡面迴圈條件——走到最後一個位置，解引用就是一個0

分析：一個類中的虛擬函式
（1）如果一個類裡面有虛擬函式，其類大小會多4個位元組
其大小為：成員大小總和+4位元組
注意：4位元組是多了一個指向虛表的指標（虛擬函式的地址即虛擬函式的表格，簡稱虛表）
（2）以下結果可以說明：虛擬函式表格裡面的虛擬函式排列次序就是它們在類裡面宣告的先後順序


此結果中類的大小為8——成員大小4+4（有虛擬函式）=8

3、定義虛擬函式的限制：

（1）非類的成員函式不能定義為虛擬函式。

（2）類的成員函式中靜態成員函式和建構函式也不能定義為虛擬函式，但可以將解構函式定義為虛擬函式。

（3）常常把基類的解構函式定義為虛擬函式。因為，將基類的解構函式定義為虛擬函式後，當利用delete刪除一個指向派生類定義的物件指標時，系統會呼叫相應的類的解構函式。而不將解構函式定義為虛擬函式時，只調用基類的解構函式。

（4）只需要在宣告函式的類體中使用關鍵字“virtual”將函式宣告為虛擬函式，而定義函式時不需要使用關鍵字“virtual”。

（5）當將基類中的某一成員函式宣告為虛擬函式後，派生類中的同名函式（函式名相同、引數列表完全一致、返回值型別相關）自動成為虛擬函式。

（6）如果聲明瞭某個成員函式為虛擬函式，則在該類中不能出現和這個成員函式同名並且返回值、引數個數、型別都相同的非虛擬函式。在以該類為基類的派生類中，也不能出現和這個成員函式同名並且返回值、引數個數、型別都相同的非虛擬函式。

二、不同繼承下帶有虛擬函式的物件模型

1、帶有虛擬函式的單繼承

class Base
{
public:
    virtual void TestFunc1()
    {
        cout << "Base::TestFunc1()" << endl;
    }
    virtual void TestFunc2()
    {
        cout << "Base::TestFunc2()" << endl;
    }
    virtual void TestFunc3()
    {
        cout << "Base::TestFunc3()" << endl;
    }

    int _b;
};

class Derived :public Base
{
public:
    int _d;
};

typedef void(*PVTF)();
void PrintVTF(Base& b,const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout <<str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
int main()
{
    cout << sizeof(Base) << endl;//8
    cout << sizeof(Derived) << endl;//12

    Base b;
    b._b = 1;

    Derived d;
    d._b = 1;
    d._d = 2;

    PrintVTF(b,"Base VTF:");
    PrintVTF(d, "Derived VTF:");
    return 0;
}

結果：
此時派生類中沒有虛擬函式的列印結果

派生類的物件模型

——在派生類中加上一個虛擬函式（重寫了之後，換成派生類自己的虛擬函式）

class Derived :public Base
{
public:
    virtual void TestFunc2() //重寫Base類中的TestFunc2()
    {
        cout << "Derived::TestFunc2()" << endl;
    }

    int _d;
};

經過派生類的重寫，打印出來以後是派生類自己的TestFunc2()

總結：

（1）基類中的虛表：將類中的虛擬函式按照在類中宣告的先後次序新增虛擬函式表中
（2）派生類中的虛表：

——將基類虛擬函式表中的內容拷貝一份（從第一個列印即如果中可以看出）。
——如果派生類重寫了基類的某個虛擬函式，使用派生類自己的虛擬函式替換派生類虛表中相同偏移量位置的基類的虛擬函式（從第二個列印即如果中可以看出）。按照派生類自己特有的虛擬函式的宣告次序將其增加到虛擬函式表的最後。

2、帶有虛擬函式的多繼承

class B1
{
public:
    virtual void TestFunc1()
    {
        cout << "B1::TestFunc1()" << endl;
    }
    virtual void TestFunc2()
    {
        cout << "B1::TestFunc2()" << endl;
    }
public:
    int _b1;
};

class B2
{
public:
    virtual void TestFunc3()
    {
        cout << "B2::TestFunc3()" << endl;
    }
    virtual void TestFunc4()
    {
        cout << "B2::TestFunc4()" << endl;
    }
public:
    int _b2;
};

class D : public B1, public B2
{
public:
    virtual void TestFunc2()
    {
        cout << "D::TestFunc2()" << endl;
    }
    virtual void TestFunc3()
    {
        cout << "D::TestFunc3()" << endl;
    }
public:
    int _d;
};

#include<string>
typedef void(*PVTF)();
void PrintVTF(B1& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
void PrintVTF(B2& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
int main()
{
    cout << sizeof(D) << endl;

    D d;
    d._b1 = 1;
    d._b2 = 2;
    d._d = 3;

    B1& b1 = d;
    PrintVTF(b1, "D VFT— > B1");
    B2& b2 = d;
    PrintVTF(b2, "D VFT— > B2");
    return 0;
}

派生類物件模型
將派生類新增加的虛擬函式放置到第一張虛表的最後。

3、帶有虛擬函式的菱形繼承（存在二義性）

class B
{
public:
    virtual void TestFunc1()
    {
        cout << "B::TestFunc1()" << endl;
    }
    virtual void TestFunc2()
    {
        cout << "B::TestFunc2()" << endl;
    }
public:
    int _b;
};

class C1 :public B
{
public:
    virtual void TestFunc1()//重寫B裡面的TestFunc1()
    {
        cout << "C1::TestFunc1()" << endl;
    }
    virtual void TestFunc3()//自己新增一個TestFunc3()
    {
        cout << "C1::TestFunc3()" << endl;
    }

    int _c1;
};

class C2 :public B
{
public:
    virtual void TestFunc2()//重寫B裡面的TestFunc2()
    {
        cout << "C2::TestFunc2()" << endl;
    }
    virtual void TestFunc4()//自己新增一個TestFunc4()
    {
        cout << "C2::TestFunc4()" << endl;
    }

    int _c2;
};

class D :public C1, public C2
{
public:
    virtual void TestFunc1()//重寫
    {
        cout << "D::TestFunc1()" << endl;
    }
    virtual void TestFunc3()//重寫
    {
        cout << "D::TestFunc3()" << endl;
    }
    virtual void TestFunc4()//重寫
    {
        cout << "D::TestFunc4()" << endl;
    }
    virtual void TestFunc5()//自己新增的
    {
        cout << "D::TestFunc5()" << endl;
    }

    int _d;
};

#include<string>
typedef void(*PVTF)();

void PrintVTF(C1& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
void PrintVTF(C2& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
int main()
{
    cout << sizeof(D) << endl;//28
    D d;
    d.C1::_b = 1;
    d._c1 = 2;

    d.C2::_b = 3;
    d._c2 = 4;
    d._d = 5;

    C1& c1 = d;
    PrintVTF(c1, "D VFT—>C1:");
    C2& c2 = d;
    PrintVTF(c2, "D VFT—>C2:");
    return 0;
}

派生類物件模型

4、帶有虛擬函式的虛擬繼承

class B
{
public:
    virtual void TestFunc1()
    {
        cout << "B::TestFunc1()" << endl;
    }
    virtual void TestFunc2()
    {
        cout << "B::TestFunc2()" << endl;
    }
public:
    int _b;
};

class D :virtual public B
{
public:
    virtual void TestFunc2()//重寫
    {
        cout << "D::TestFunc2()" << endl;
    }
    virtual void TestFunc3()//自己新增的
    {
        cout << "D::TestFunc3()" << endl;
    }

    int _d;
};

#include<string>
typedef void(*PVTF)();

void PrintVTF(B& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}

int main()
{
    cout << sizeof(D) << endl;//16

    int a = -4;
    D d;
    d._b = 1;
    d._d = 2;

    B& b = d;
    PrintVTF(b, "D—>B:");
    PrintVTF(d, "D—>D:");
    return 0;
}

派生類物件的模型

（1）派生類未增加新的虛擬函式

（2）派生類增加了新的虛擬函式

5、帶有虛擬函式的菱形虛擬繼承

class B
{
public:
    virtual void TestFunc1()
    {
        cout << "B::TestFunc1()" << endl;
    }
    virtual void TestFunc2()
    {
        cout << "B::TestFunc2()" << endl;
    }
    int _b;
};

class C1 :virtual public B
{
public:
    virtual void TestFunc1()//重寫B裡面的TestFunc1()
    {
        cout << "C1::TestFunc1()" << endl;
    }
    virtual void TestFunc3()//自己新增一個TestFunc3()
    {
        cout << "C1::TestFunc3()" << endl;
    }

    int _c1;
};
class C2 :virtual public B
{
public:
    virtual void TestFunc2()//重寫B裡面的TestFunc2()
    {
        cout << "C2::TestFunc2()" << endl;
    }
    virtual void TestFunc4()//自己新增一個TestFunc4()
    {
        cout << "C2::TestFunc4()" << endl;
    }

    int _c2;
};

class D :public C1, public C2
{
public:
    virtual void TestFunc1()//重寫
    {
        cout << "D::TestFunc1()" << endl;
    }
    virtual void TestFunc3()//重寫
    {
        cout << "D::TestFunc3()" << endl;
    }
    virtual void TestFunc4()//重寫
    {
        cout << "D::TestFunc4()" << endl;
    }
    virtual void TestFunc5()//新增加的
    {
        cout << "D::TestFunc5()" << endl;
    }

    int _d;
};

#include<string>
typedef void(*PVTF)();
void PrintVTF(B& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
void PrintVTF(C1& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}
void PrintVTF(C2& b, const string& str)//列印虛擬函式
{
    PVTF* pVTF = (PVTF*)(*(int*)&b);
    cout << str << endl;
    while (*pVTF)//走到最後一個位置，解引用就是一個0
    {
        (*pVTF)();//調這個函式
        ++pVTF;
    }
    cout << endl;
}

int main()
{
    cout << sizeof(D) << endl;//36
    D d;
    d._b = 1;
    d._c1 = 2;
    d._c2 = 3;
    d._d = 4;

    B& b = d;
    PrintVTF(b, "D VFT—>B:");
    C1& c1 = d;
    PrintVTF(c1, "D VFT—>C1:");
    C2& c2 = d;
    PrintVTF(c2, "D VFT—>C2:");
    return 0;
}

派生類的物件模型
（1）移量表格

（2）虛表

經過程式碼驗證，結果正確

附加：在C1、C2和D類里加入建構函式或者解構函式，則派生類大小多了4位元組

相關推薦

【C++】——多型（下）再探虛表&amp;不同繼承下帶有虛擬函式的物件模型

一、虛擬函式 1、概念：簡單地說，那些被virtual關鍵字修飾的成員函式，就是虛擬函式。虛擬函式的作用，用專業術語來解釋就是實現多型。 2、程式碼示例： class Base { public: virtual void TestFunc1() {

【C++】—多型（上）動態多型

一、多型 1、 概念：同一事物表現出的多種形態，同一操作作用於不同的物件，可以有不同的解釋，產生不同的執行結果。在執行時，可以通過指向基類的指標，來呼叫實現派生類中的方法。 2、 舉例子： #include<windows.h> class WashRoom { pu

【Fortinet】飛塔（FortiGate）防火墻低端產品命令行下配置RIP

rip fortinet forgate 飛塔防火墻 命令行配置rip 前言：FortiGate中端、高端產品支持web頁面配置RIP/OSPF/BGP，低端（桌面級）產品不支持，只支持CLI配置------雖然官網有手冊（英文版），但沒有實際案例，並給出建立連接的結果來的舒服~~這就是此

【c#】隊列（Queue）和MSMQ（消息隊列）的基礎使用

點擊 exist director except 去除 ring 出現 修改 展示 原文:【c#】隊列（Queue）和MSMQ（消息隊列）的基礎使用 首先我們知道隊列是先進先出的機制，所以在處理並發是個不錯的選擇。然後就寫兩個隊列的簡單應用。 Queue 命

【C++】類模板（template）

需求：寫一個可變長度的陣列類Array，用於存放若干元素，個數未知 設計：內部動態申請一個buffer            capacity：表示buffer的大小         &n

【C++】前置操作符（++i）和後置操作符（i++）

 一、自增和自減的基本使用方法 自增的兩種形式：  i++ i 的值作為返回值，i 自增 1； ++i i 自增 1，i 的值作為返回值。 Example: #include <iostream> #include <string&

【C#】知識點總結（一）

一、概念：.net與c# . net/dotnet：一般指 .Net  Framework框架，一種平臺，一種技術。 C#（sharp）：一種程式語言，可以開發基於.net平臺的應用。 Java是一種技術、一種程式語言。   二、.net能幹什麼（必須掌握）

【C++】多型的理解

一.多型的概念 簡單的講就是同一事物在不同條件下所呈現出來的不同形態 舉例：火車站的同一視窗成人售票就是全價票，學生就是半價票。這就是同一事物，但是在不同的條件下可以呈現處不同的形態。有點見人說人話，見鬼說鬼話的意思。 二.多型的實現 #include<io

【Java】泛型（Generics）

What    顧名思義，泛型：一般型別，也就是說可以為任何型別，泛型的本質是“引數化型別”，也就是說所操作的資料型別被指定為一個引數。泛型是在JDK1.5中引入的特性。 Why    泛型提供了編譯時型別安全檢測機制，該機制允

【c++】多型&多型物件模型

1.多型： 在C ++程式設計中，多型性是指具有不同功能的函式可以用同一個函式名，這樣就可以用一個函式名呼叫不同內容的函式。在面向物件方法中一般是這樣表述多型性的：向不同的物件傳送同一個訊息， 不同的物件在接收時會產生不同的行為（即方法）。也就是說，每個物件可以用自己的方式

【c++知識歸納】繼承與多型（一）

        c++是基於面向物件的程式語言,面向物件的三大特性為：封裝、繼承和多型。本文對繼承與多型的知識點進行了總結歸納，這部分內容對於學習c++程式語言是非常重要的，文章加入我的個人理解，希望

【C語言天天練（二）】statickeyword

修飾 weight () main函數 class code keyword spa tail 引言： statickeyword不僅能夠修飾變量。並且能夠修飾函數。了解它的使用方法，不僅對閱讀別人的代碼有幫助，也有助於自己寫出更加健壯的

【C語言天天練（三）】typedef具體解釋

tar 原因 外部 指向 可用 引入 解釋 trac 兩個 引言： typedef能夠看作type define的縮寫，顧名思義就是類型定義，也就是說它僅僅是給已有的類型又一次定義了一個方便使用的別名。並沒有產生新的數據類型。 typed

5、【C++】指標/引用（指標和引用的區別）

一、指標 int p=12; int *q; int *q=&p;     這裡p為int型別的變數，&p就是p的記憶體地址，*q是一個int型別的變數（是一個值），q為指標是地址，int q=&p;把p的地址賦給了指標q,所以q就

【C++】auto關鍵字（c++11）

概念 C++11中，auto不再是一個儲存型別指示符，而是一個自動推導變數的型別，如： #include <iostream> #include <typeinfo> using namespace std; int TestAuto() { ret

【C++】名字空間（解決名字衝突問題二）

目錄 名字空間定義 名字空間使用 頭源分離 同一名稱空間在多個檔案中  一般自己是不會使用的，但一些大型的庫可能用到，比如名稱空間std. 名字空間定義 解決名字衝突問題的究極解決方法：namespace（名字空間） 語法為： name

【C++】內部類（解決名字衝突問題一）

將內部類看成普通成員，符合普通成員的規則，用法就是正常類的使用方法。 定義內部類 把一個類的定義寫在另一個類的內部，則成裡面的這個類為內部類。例如，下面程式碼中的Inner類 #include <stdio.h> #include <string.h>

C語言面向物件程式設計：虛擬函式與多型（3）

 在《 C++ 程式設計思想》一書中對虛擬函式的實現機制有詳細的描述，一般的編譯器通過虛擬函式表，在編譯時插入一段隱藏的程式碼，儲存型別資訊和虛擬函式地址，而在呼叫時，這段隱藏的程式碼可以找到和實際物件一致的虛擬函式實現。     我們在這裡提供

從零開始學C++之虛擬函式與多型（一）：虛擬函式表指標、虛解構函式、object slicing與虛擬函式、C++物件模型圖

#include <iostream>using namespace std;class CObject {public:     virtual void Serialize()     {         cout << "CObject::Serialize ..." <&

C++多型（上）——虛擬函式、虛表

OOP的核心思想是多型性（polymorphism）。其含義是“多種形態”。我們把具有繼承關係的多個型別稱為多型型別。引用或指標的靜態型別和動態型別不同這一事實正是C++語言支援多型性的根本所在。 多型性：當用於面向物件程式設計的範疇時，多型性的含義是指