2. 程式人生 > >C++ 虛函數表淺析

C++ 虛函數表淺析

阿新 • • 發佈：2018-02-13
tab -s names 寫到 style quest ios mes 沒有

一、背景知識（一些基本概念）

虛函數（Virtual Function）：在基類中聲明為 virtual 並在一個或多個派生類中被重新定義的成員函數。

純虛函數（Pure Virtual Function）：基類中沒有實現體的虛函數稱為純虛函數（有純虛函數的基類稱為虛基類）。 C++ “虛函數”的存在是為了實現面向對象中的“多態”，即父類類別的指針（或者引用）指向其子類的實例，然後通過父類的指針（或者引用）調用實際子類的成員函 數。通過動態賦值，實現調用不同的子類的成員函數（動態綁定）。正是因為這種機制，把析構函數聲明為“虛函數”可以防止在內存泄露。

實例：

技術分享圖片 
#include <iostream>
using namespace std;

class base_class
{
public:
    base_class()
    {
    }
    virtual ~base_class()
    {
    }

    int normal_func()
    {
        cout << "This is  base_class‘s normal_func()" << endl;
        return 0;
    }
    virtual int virtual_fuc()
    {
        cout << "This is  base_class‘s virtual_fuc()" << endl;
        return 0;
    }

};

class drived_class1 : public base_class
{
public:
    drived_class1()
    {
    }
    virtual ~drived_class1()
    {
    }

    int normal_func()
    {
        cout << "This is  drived_class1‘s normal_func()" << endl;
        return 0;
    }
    virtual int virtual_fuc()
    {
        cout << "This is  drived_class1‘s virtual_fuc()" << endl;
        return 0;
    }
};

class drived_class2 : public base_class
{
public:
    drived_class2()
    {
    }
    virtual ~drived_class2()
    {
    }

    int normal_func()
    {
        cout << "This is  drived_class2‘s normal_func()" << endl;
        return 0;
    }
    virtual int virtual_fuc()
    {
        cout << "This is  drived_class2‘s virtual_fuc()" << endl;
        return 0;
    }
};

int main()
{
    base_class * pbc = NULL;
    base_class bc;
    drived_class1 dc1;
    drived_class2 dc2;

    pbc = &bc;
    pbc->normal_func();
    pbc->virtual_fuc();

    pbc = &dc1;
    pbc->normal_func();
    pbc->virtual_fuc();

    pbc = &dc2;
    pbc->normal_func();
    pbc->virtual_fuc();
    return 0;

}
技術分享圖片

輸出結果：

This is  base_class‘s normal_func()
This is  base_class‘s virtual_fuc()
This is  base_class‘s normal_func()
This is  drived_class1‘s virtual_fuc()
This is  base_class‘s normal_func()
This is  drived_class2‘s virtual_fuc()

假如將 base_class 類中的 virtual_fuc() 寫成下面這樣（純虛函數，虛基類）：

// 無實現體
virtual int virtual_fuc() = 0;

那麽 virtual_fuc() 是一個純虛函數，base_class 就是一個虛基類：不能實例化（即不能用它來定義對象），只能聲明指針或者引用。讀者可以自行測試，這裏不再給出實例。

虛函數表(Virtual Table，V-Table)：使用 V-Table 實現 C++ 的多態。在這個表中，主要是一個類的虛函數的地址表，這張表解決了繼承、覆蓋的問題，保證其真實反應實際的函數。這樣，在有虛函數的類的實例中分配了指向 這個表的指針的內存，所以，當用父類的指針來操作一個子類的時候，這張虛函數表就顯得尤為重要了，它就像一個地圖一樣，指明了實際所應該調用的函數。

編譯器應該保證虛函數表的指針存在於對象實例中最前面的位置（這是為了保證取到虛函數表的有最高的性能——如果有多層繼承或是多重繼承的情況下）。

這意味著可以通過對象實例的地址得到這張虛函數表，然後就可以遍歷其中函數指針，並調用相應的函數。

二、無繼承時的虛函數表

技術分享圖片 
#include <iostream>
using namespace std;

class base_class
{
public:
    virtual void v_func1()
    {
        cout << "This is base_class‘s v_func1()" << endl;
    }
    virtual void v_func2()
    {
        cout << "This is base_class‘s v_func2()" << endl;
    }
    virtual void v_func3()
    {
        cout << "This is base_class‘s v_func3()" << endl;
    }
};

int main()
{
    // 查看 base_class 的虛函數表
    base_class bc;
    cout << "base_class 的虛函數表首地址為：" << (int*)&bc << endl; // 虛函數表地址存在對象的前四個字節
    cout << "base_class 的 第一個函數首地址：" << (int*)*(int*)&bc+0 << endl; // 指針運算看不懂？沒關系，一會解釋給你聽
    cout << "base_class 的 第二個函數首地址：" << (int*)*(int*)&bc+1 << endl;
    cout << "base_class 的 第三個函數首地址：" << (int*)*(int*)&bc+2 << endl;
    cout << "base_class 的 結束標誌: " << *((int*)*(int*)&bc+3) << endl;

    // 通過函數指針調用函數，驗證正確性
    typedef void(*func_pointer)(void);
    func_pointer fp = NULL;
    fp = (func_pointer)*((int*)*(int*)&bc+0); // v_func1()
    fp();
    fp = (func_pointer)*((int*)*(int*)&bc+1); // v_func2()
    fp();
    fp = (func_pointer)*((int*)*(int*)&bc+2); // v_func3()
    fp();
    return 0;
}
技術分享圖片

輸出結果：

技術分享圖片 
base_class 的虛函數表首地址為：0x22ff0c
base_class 的 第一個函數首地址：0x472c98
base_class 的 第二個函數首地址：0x472c9c
base_class 的 第三個函數首地址：0x472ca0
base_class 的虛函數表結束標誌: 0
This is base_class‘s v_func1()
This is base_class‘s v_func2()
This is base_class‘s v_func3()
技術分享圖片

簡單的解釋一下代碼中的指針轉換：

  • &bc：獲得 bc 對象的地址。
  • (int)&bc: 類型轉換，獲得虛函數表的首地址。這裏使用 int 的原因是函數指針的大小的 4byte，使用 int 可以使得他們每次的偏移量保持一致（sizeof(int) = 4，32-bit機器）。
  • (int)&bc：解指針引用，獲得虛函數表。
  • (int)(int*)&bc+0：和上面相同的類型轉換，獲得虛函數表的第一個虛函數地址。
  • (int)(int*)&bc+1：同上，獲得第二個函數地址。
  • (int)(int*)&bc+2：同上，獲得第三個函數地址。
  • ((int)(int)&bc+3)：獲得虛函數表的結束標誌，所以這裏我解引用了。和我們使用鏈表的情況是一樣的，虛函數表當然也需要一個結束標誌。
  • typedef void(*func_pointer)(void)：定義一個函數指針，參數和返回值都是 void。

對於指針的轉換，我就解釋這麽多了。下面的文章，我不再做解釋，相信大家可以舉一反三。如果你覺得很費解的話，我不建議繼續去看這篇文章了，建議你去補一補基礎（《C和指針》是一本很好的選擇哦！）。 通過上面的例子的嘗試和輸出結果，我們可以得出下面的布局圖示：

技術分享圖片

三、單一繼承下的虛函數表

3.1 子類沒有重寫父類的虛函數

（陳皓文章中用了“覆蓋”一詞，我覺得太合理，但是我又找不到更合理的詞語，所以就用一個句子代替了。^-^）

技術分享圖片 
#include <iostream>
using namespace std;

class base_class
{
public:
    virtual void v_func1()
    {
        cout << "This is base_class‘s v_func1()" << endl;
    }
    virtual void v_func2()
    {
        cout << "This is base_class‘s v_func2()" << endl;
    }
    virtual void v_func3()
    {
        cout << "This is base_class‘s v_func3()" << endl;
    }
};
class dev_class : public base_class
{
public:
    virtual void v_func4()
    {
        cout << "This is dev_class‘s v_func4()" << endl;
    }
    virtual void v_func5()
    {
        cout << "This is dev_class‘s v_func5()" << endl;
    }
};

int main()
{
    // 查看 dev_class 的虛函數表
    dev_class dc;
    cout << "dev_class 的虛函數表首地址為：" << (int*)&dc << endl;
    cout << "dev_class 的 第一個函數首地址：" << (int*)*(int*)&dc+0 << endl;
    cout << "dev_class 的 第二個函數首地址：" << (int*)*(int*)&dc+1 << endl;
    cout << "dev_class 的 第三個函數首地址：" << (int*)*(int*)&dc+2 << endl;
    cout << "dev_class 的 第四個函數首地址：" << (int*)*(int*)&dc+3 << endl;
    cout << "dev_class 的 第五個函數首地址：" << (int*)*(int*)&dc+4 << endl;
    cout << "dev_class 的虛函數表結束標誌: " << *((int*)*(int*)&dc+5) << endl;
    // 通過函數指針調用函數，驗證正確性
    typedef void(*func_pointer)(void);
    func_pointer fp = NULL;
    for (int i=0; i<5; i++) {
        fp = (func_pointer)*((int*)*(int*)&dc+i);
        fp();
    }
    return 0;
}
技術分享圖片

輸出結果：

技術分享圖片 
dev_class 的虛函數表首地址為：0x22ff0c
dev_class 的 第一個函數首地址：0x472d10
dev_class 的 第二個函數首地址：0x472d14
dev_class 的 第三個函數首地址：0x472d18
dev_class 的 第四個函數首地址：0x472d1c
dev_class 的 第五個函數首地址：0x472d20
dev_class 的虛函數表結束標誌: 0
This is base_class‘s v_func1()
This is base_class‘s v_func2()
This is base_class‘s v_func3()
This is dev_class‘s v_func4()
This is dev_class‘s v_func5()
技術分享圖片

通過上面的例子的嘗試和輸出結果，我們可以得出下面的布局圖示：

技術分享圖片

可以看出，v-table中虛函數是順序存放的，先基類後派生類。

3.2 子類有重寫父類的虛函數

技術分享圖片 
#include <iostream>
using namespace std;

class base_class
{
public:
    virtual void v_func1()
    {
        cout << "This is base_class‘s v_func1()" << endl;
    }
    virtual void v_func2()
    {
        cout << "This is base_class‘s v_func2()" << endl;
    }
    virtual void v_func3()
    {
        cout << "This is base_class‘s v_func3()" << endl;
    }
};
class dev_class : public base_class
{
public:
    virtual void v_func1()
    {
        cout << "This is dev_class‘s v_func1()" << endl;
    }
    virtual void v_func2()
    {
        cout << "This is dev_class‘s v_func2()" << endl;
    }
    virtual void v_func4()
    {
        cout << "This is dev_class‘s v_func4()" << endl;
    }
    virtual void v_func5()
    {
        cout << "This is dev_class‘s v_func5()" << endl;
    }
};

int main()
{
    // 查看 dev_class 的虛函數表
    dev_class dc;
    cout << "dev_class 的虛函數表首地址為：" << (int*)&dc << endl;
    cout << "dev_class 的 第一個函數首地址：" << (int*)*(int*)&dc+0 << endl;
    cout << "dev_class 的 第二個函數首地址：" << (int*)*(int*)&dc+1 << endl;
    cout << "dev_class 的 第三個函數首地址：" << (int*)*(int*)&dc+2 << endl;
    cout << "dev_class 的 第四個函數首地址：" << (int*)*(int*)&dc+3 << endl;
    cout << "dev_class 的 第五個函數首地址：" << (int*)*(int*)&dc+4 << endl;
    cout << "dev_class 的虛函數表結束標誌: " << *((int*)*(int*)&dc+5) << endl;
    // 通過函數指針調用函數，驗證正確性
    typedef void(*func_pointer)(void);
    func_pointer fp = NULL;
    for (int i=0; i<5; i++) {
        fp = (func_pointer)*((int*)*(int*)&dc+i);
        fp();
    }
    return 0;
}
技術分享圖片

輸出結果：

技術分享圖片 
dev_class 的虛函數表首地址為：0x22ff0c
dev_class 的 第一個函數首地址：0x472d50
dev_class 的 第二個函數首地址：0x472d54
dev_class 的 第三個函數首地址：0x472d58
dev_class 的 第四個函數首地址：0x472d5c
dev_class 的 第五個函數首地址：0x472d60
dev_class 的虛函數表結束標誌: 0
This is dev_class‘s v_func1()
This is dev_class‘s v_func2()
This is base_class‘s v_func3()
This is dev_class‘s v_func4()
This is dev_class‘s v_func5()
技術分享圖片

通過上面的例子的嘗試和輸出結果，我們可以得出下面的布局圖示：

技術分享圖片

可以看出：當派生類中 dev_class 中重寫了父類 base_class 的前兩個虛函數（v_func1，v_func2）之後，使用派生類的虛函數指針代替了父類的虛函數。未重寫的父類虛函數位置沒有發生變化。

不知道看到這裏，你心裏有沒有一個小問題？至少我是有的。看下面的代碼：

virtual void v_func1()
{
    base_class::v_func1();
    cout << "This is dev_class‘s v_func1()" << endl;
}

既然派生類的虛函數表中用 dev_class::v_func1 指針代替了 base_class::v_func1，假如我顯示的調用

base_class::v_func1，會不會有錯呢？答案是沒錯的，可以正確的調用！不是覆蓋了嗎？dev_class 已經不知道 base_class::v_func1 的指針了，怎麽調用的呢？

如果你想知道原因，請關註這兩個帖子：

  • http://stackoverflow.com/questions/11426970/why-can-a-derived-class-virtual-function-call-a-base-class-virtual-fuction-how
  • http://topic.csdn.net/u/20120711/14/fa9cfba2-8814-4119-8290-99e6af2c21f4.html?seed=742904136&r=79093804#r_79093804

四、多重繼承下的虛函數表

4.1子類沒有重寫父類的虛函數

技術分享圖片 
#include <iostream>
using namespace std;

class base_class1
{
public:
    virtual void bc1_func1()
    {
        cout << "This is bc1_func1‘s v_func1()" << endl;
    }
};

class base_class2
{
public:
    virtual void bc2_func1()
    {
        cout << "This is bc2_func1‘s v_func1()" << endl;
    }
};

class dev_class : public base_class1, public base_class2
{
public:
    virtual void dc_func1()
    {
        cout << "This is dc_func1‘s dc_func1()" << endl;
    }
};

int main()
{
    dev_class dc;
    cout << "dc 的虛函數表 bc1_vt 地址：" << (int*)&dc << endl;
    cout << "dc 的虛函數表 bc1_vt 第一個虛函數地址：" << (int*)*(int*)&dc+0 << endl;
    cout << "dc 的虛函數表 bc1_vt 第二個虛函數地址：" << (int*)*(int*)&dc+1 << endl;
    cout << "dc 的虛函數表 bc1_vt 結束標誌：" << *((int*)*(int*)&dc+2) << endl;
    cout << "dc 的虛函數表 bc2_vt 地址：" << (int*)&dc+1 << endl;
    cout << "dc 的虛函數表 bc2_vt 第一個虛函數首地址：：" << (int*)*((int*)&dc+1)+0 << endl;
    cout << "dc 的虛函數表 bc2_vt 結束標誌：" << *((int*)*((int*)&dc+1)+1) << endl;
    // 通過函數指針調用函數，驗證正確性
    typedef void(*func_pointer)(void);
    func_pointer fp = NULL;
    // bc1_vt
    fp = (func_pointer)*((int*)*(int*)&dc+0);
    fp();
    fp = (func_pointer)*((int*)*(int*)&dc+1);
    fp();
    // bc2_vt
    fp = (func_pointer)*(((int*)*((int*)&dc+1)+0));
    fp();
    return 0;
}
技術分享圖片

輸出結果：

技術分享圖片 
dc 的虛函數表 bc1_vt 地址：0x22ff08
dc 的虛函數表 bc1_vt 第一個虛函數地址：0x472d38
dc 的虛函數表 bc1_vt 第二個虛函數地址：0x472d3c
dc 的虛函數表 bc1_vt 結束標誌：-4
dc 的虛函數表 bc2_vt 地址：0x22ff0c
dc 的虛函數表 bc2_vt 第一個虛函數首地址：：0x472d48
dc 的虛函數表 bc2_vt 結束標誌：0
This is bc1_func1‘s v_func1()
This is dc_func1‘s dc_func1()
This is bc2_func1‘s v_func1()
技術分享圖片

通過上面的例子的嘗試和輸出結果，我們可以得出下面的布局圖示：

技術分享圖片

可以看出：多重繼承的情況，會為每一個基類建一個虛函數表。派生類的虛函數放到第一個虛函數表的後面。

陳皓在他的文章中有這麽一句話：“這個結束標誌（虛函數表）的值在不同的編譯器下是不同的。在WinXP+VS2003下，這個值是NULL。而在 Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，這個值是如果1，表示還有下一個虛函數表，如果值是0，表示是最後一個虛函數表。”我在 Windows 7 + Code::blocks 10.05 下嘗試，這個值是如果是 -4，表示還有下一個虛函數表，如果是0，表示是最後一個虛函數表。我在 Windows 7 + vs2010 下嘗試，兩個值都是 0 。

4.2子類重寫了父類的虛函數

技術分享圖片 
#include <iostream>
using namespace std;

class base_class1
{
public:
    virtual void bc1_func1()
    {
        cout << "This is base_class1‘s bc1_func1()" << endl;
    }
    virtual void bc1_func2()
    {
        cout << "This is base_class1‘s bc1_func2()" << endl;
    }
};

class base_class2
{
public:
    virtual void bc2_func1()
    {
        cout << "This is base_class2‘s bc2_func1()" << endl;
    }
    virtual void bc2_func2()
    {
        cout << "This is base_class2‘s bc2_func2()" << endl;
    }
};

class dev_class : public base_class1, public base_class2
{
public:
    virtual void bc1_func1()
    {
        cout << "This is dev_class‘s bc1_func1()" << endl;
    }
    virtual void bc2_func1()
    {
        cout << "This is dev_class‘s bc2_func1()" << endl;
    }
    virtual void dc_func1()
    {
        cout << "This is dev_class‘s dc_func1()" << endl;
    }
};

int main()
{
    dev_class dc;
    cout << "dc 的虛函數表 bc1_vt 地址：" << (int*)&dc << endl;
    cout << "dc 的虛函數表 bc1_vt 第一個虛函數地址：" << (int*)*(int*)&dc+0 << endl;
    cout << "dc 的虛函數表 bc1_vt 第二個虛函數地址：" << (int*)*(int*)&dc+1 << endl;
    cout << "dc 的虛函數表 bc1_vt 第三個虛函數地址：" << (int*)*(int*)&dc+2 << endl;
    cout << "dc 的虛函數表 bc1_vt 第四個虛函數地址：" << (int*)*(int*)&dc+3 << endl;
    cout << "dc 的虛函數表 bc1_vt 結束標誌：" << *((int*)*(int*)&dc+4) << endl;
    cout << "dc 的虛函數表 bc2_vt 地址：" << (int*)&dc+1 << endl;
    cout << "dc 的虛函數表 bc2_vt 第一個虛函數首地址：：" << (int*)*((int*)&dc+1)+0 << endl;
    cout << "dc 的虛函數表 bc2_vt 第二個虛函數首地址：：" << (int*)*((int*)&dc+1)+1 << endl;
    cout << "dc 的虛函數表 bc2_vt 結束標誌：" << *((int*)*((int*)&dc+1)+2) << endl;
    // 通過函數指針調用函數，驗證正確性
    typedef void(*func_pointer)(void);
    func_pointer fp = NULL;
    // bc1_vt
    fp = (func_pointer)*((int*)*(int*)&dc+0);
    fp();
    fp = (func_pointer)*((int*)*(int*)&dc+1);
    fp();
    fp = (func_pointer)*((int*)*(int*)&dc+2);
    fp();
    fp = (func_pointer)*((int*)*(int*)&dc+3);
    fp();
    // bc2_vt
    fp = (func_pointer)*(((int*)*((int*)&dc+1)+0));
    fp();
    fp = (func_pointer)*(((int*)*((int*)&dc+1)+1));
    fp();
    return 0;
}
技術分享圖片

輸出結果：

技術分享圖片 
dc 的虛函數表 bc1_vt 地址：0x22ff08
dc 的虛函數表 bc1_vt 第一個虛函數地址：0x472e28
dc 的虛函數表 bc1_vt 第二個虛函數地址：0x472e2c
dc 的虛函數表 bc1_vt 第三個虛函數地址：0x472e30
dc 的虛函數表 bc1_vt 第四個虛函數地址：0x472e34
dc 的虛函數表 bc1_vt 結束標誌：-4
dc 的虛函數表 bc2_vt 地址：0x22ff0c
dc 的虛函數表 bc2_vt 第一個虛函數首地址：：0x472e40
dc 的虛函數表 bc2_vt 第一個虛函數首地址：：0x472e44
dc 的虛函數表 bc2_vt 結束標誌：0
This is dev_class‘s bc1_func1()
This is base_class1‘s bc1_func2()
This is dev_class‘s bc2_func1()
This is dev_class‘s dc_func1()
This is dev_class‘s bc2_func1()
This is base_class2‘s bc2_func2()
技術分享圖片

通過上面的例子的嘗試和輸出結果，我們可以得出下面的布局圖示：

技術分享圖片

是不是感覺很亂？其實一點都不亂！就是兩個單繼承而已。把多余的部分（派生類的虛函數）增加到第一個虛函數表的最後，CB（Code::Blocks）是這樣實現的。我試了一下，vs2010不是這樣實現的，讀者可以自己嘗試一下。本文只針對 CB 來探討。

有人覺得多重繼承不好理解。我想如果你明白了它的虛函數表是怎麽樣的，也就沒什麽不好理解了吧。

也許還有人會說，不同的編譯器實現方式是不一樣的，我去研究某一種編譯器的實現有什麽意義呢？我個人理解是這樣的：

  • 實現方式是不一樣的，但是它們的實現結果是一樣的（多態）。
  • 無論你了解虛函數表或者不了解虛函數表，我相信你都很少會用到它。但是當你了解了它的實現機制之後，你再去看多態，再去寫虛函數的時候[作為你一個coder]，相信你的感覺是不一樣的。你會感覺很透徹，不會有絲毫的猶豫。
  • 學習編譯器這種處理問題的方式（思想），這才是最重要的。[好像扯遠了，^-^]。

如果你了解了虛函數表之後，可以通過虛函數表直接訪問類的方法，這種訪問是不受成員的訪問權限限制的（private，protected）。這樣做是很危險的，但是確實是可以這樣做的。這也是C++為什麽很危險的語言的一個原因……

寫到這裏，文章也就基本結束了。作為讀者的你，看完之後，你不是產生了許多其他的問題呢？作為筆者的我，有了新幾個問題[我這人問題特別多。^-^]比如：

  • 訪問權限是怎麽實現的？編譯器怎麽知道哪些函數是public，哪些是protected？
  • 虛函數調用是通過虛函數表實現的，那麽非虛成員函數存放在哪裏？是怎麽實現的呢？
  • 類的成員存放在什麽位置？怎麽繼承的呢？[這是對象布局問題，=.=]

你知道的越多，你感覺你知道的越少。推薦大家一本書吧，《深度探索C++對象模型》（英文名字是《Inside to C++ Object Model》），看完你會明白很多。

感謝閱讀，下面列出參考資料[順便給大家推薦一下陳皓的博客吧:http://coolshell.cn/，經常去逛逛，會學到很多，至少我是這樣覺得的。^-^]：

  • http://blog.csdn.net/haoel/article/details/1948051/
  • http://baike.baidu.com/view/3750123.htm
  • http://www.cnblogs.com/wirelesser/archive/2008/03/09/1097463.html

C++ 虛函數表淺析

相關推薦

C++ 虛函數表淺析

tab -s names 寫到 style quest ios mes 沒有 一、背景知識（一些基本概念） 虛函數（Virtual Function）：在基類中聲明為 virtual 並在一個或多個派生類中被重新定義的成員函數。 純虛函數（Pure Virtual Func

C++ 虛函數表解析

不同 存在 是我 fun 目前 details deb 比較 clu C++ 虛函數表解析 前言 原文地址：http://blog.csdn.net/haoel/article/details/1948051/ C++中的虛函數的作用主要是實現了多態的機制。關於多態，簡

獲取C++虛函數表地址和虛函數地址

rtu 虛函數地址 cpp 32位 對象 知識點 cout virt def 1.先介紹C++類的內存結構，大家可以看以下博客，覺得不錯 　　https://blog.csdn.net/fenxinzi557/article/details/51995911 　　其中和本次

C++虛函數表解析

一個 位置 子類的成員函數 table gic 重載 vs2003 靜態 壞事 C++ 虛函數表解析<?xml:namespace prefix = o /> 陳皓 http://blog.csdn.net/haoel 前言 C++中

C++跟我一起透徹理解虛函數表

技術 覆蓋 text 編譯 pretty ring 對象 virt roc //首先讓我們來了解類對象的構造順序。 #include <iostream> using namespace std; class A { public:

深入剖析C++多態、VPTR指針、虛函數表

const 成員函數 virtual函數 並且 () 簡單 2-2 close display 在講多態之前，我們先來說說關於多態的一個基石------類型兼容性原則。 一、背景知識 　　1.類型兼容性原則　 　　類型兼容規則是指在需要基類對象的任何地方，都可以使用公

C++對象的內存分布和虛函數表

關鍵字 lin 指針 ostream 提取 發生 布局 派生 重載 c++中一個類中無非有四種成員：靜態數據成員和非靜態數據成員，靜態函數和非靜態函數。 1.非靜態數據成員被放在每一個對象體內作為對象專有的數據成員。 2.靜態數據成員被提取出來放在程序的靜態數

C++ Daily 《5》----虛函數表的共享問題

.net class pre int 全部 版權 ++ trac end 版權聲明：本文為博主原創文章，未經博主同意不得轉載。 https://blog.csdn.net/u012653791/article/details/25537

C++ 虛函數的使用

ios public 繼承 str 定義 spa 機制 called blog 虛函數是C++中用於實現多態(polymorphism)的機制。核心理念就是通過基類訪問派生類定義的函數。假設我們有下面的類層次： #include <iostream> usin

C++ 虛函數 、純虛函數、接口的實用方法和意義

函數聲明 函數 order ack 創建 無需 art %d 最終 也許之前我很少寫代碼，更很少寫面向對象的代碼，即使有寫多半也很容易寫回到面向過程的老路上去。在寫面向過程的代碼的時候，根本不管什麽函數重載和覆蓋，想到要什麽功能就變得法子的換個函數名字，心裏想想：反正函數重

c++虛函數實現與this指針

ive 我們 構造 public 註意 col 入口 一個 成員 我們知道當我們sizeof 一個類的時候，類的成員函數是不計算在對象的大小的裏的，這是為什麽呢？因為類的成員函數不是屬於某一個對象的，而是類的所有對象所共享的，就像static變量那樣。如果虛函數和普通成員函

C++ 虛函數的內存分配

技術 虛指針 title 為什麽 data- 而是 c++ 調試 nbsp 1.無繼承的普通類： 在有虛函數的情況下類會為其增加一個隱藏的成員，虛函數表指針，指向一個虛函數表，虛函數表裏面就是類的各個虛函數的地址了。那麽，虛函數表指針是以什麽模型加入到類裏面的，虛函數

反匯編探索C++虛函數實現多態的機制

虛函數虛函數是C++實現多態的機制，那麽它是如何做到的呢？以下通過反匯編探索虛函數內存模型，查看虛函數實現多態的過程。工具Visual studio 2017：以下程序僅做VC++編譯器下的32位程序探討，其他編譯器與64位程序所產生的差異不作討論。反匯編過程首先聲明一個不包含虛函數的簡單C++類，如下：在構

C++虛函數總結

允許 col match 屬於 不能 nat tool 代碼 抽象類 為什麽使用虛函數？什麽是虛函數？虛函數是為了解決什麽問題？ 面向對象的三大特征： 封裝 多態 繼承 普通虛函數 虛析構函數 純虛函數 抽象類 接口類 隱藏 vs 覆蓋 隱藏與覆蓋之間的關系 早綁定和

c++虛函數重寫的權限問題

spa static mes ptr cast str iostream 調用 函數 cbase.h: 　#ifndef CBASE_H #define CBASE_H #include<iostream> using std::cout; using std:

虛函數表：QT5與VS2015的差異

name bubuko 現象 type src 結果 問題 理論 常識 問題原自下面一段代碼： 初學C++虛函數表時，以下代碼在QT和VS（版本如題）編譯結果不同。 1 #include <iostream> 2 using namespace std;

虛函數表

重新 進行 info com ima mage 新增 中繼 派生 以上述類型為例： void a_fun_1();為基類虛函數，在派生類b中沒有重新進行定義； void a_fun_2();為基類虛函數，在派生類b

C++ 虛函數的兩個例子

sfm argc int() 虛函數 spa include 一個 add 第一個 1. 第一個例子是朋友告訴我Qt中的某個實現 1 #include <iostream> 2 3 // Qt中的某個實現 4 class A{ 5 public:

深入淺出理解c++虛函數

概念 sdn 設計思想 的人 cti nothing 都是 lba gpo 深入淺出理解c++虛函數 記得幾個月前看過C++虛函數的問題，當時其實就看懂了，最近筆試中遇到了虛函數竟然不太確定，所以還是理解的不深刻，所以想通過這篇文章來鞏固下。 裝逼一刻：

swift protocol 見證容器 虛函數表 與 動態派發

ocp with deb .cn inline contain sta case spa 一、測試代碼： //protocol DiceGameDelegate: AnyObject { //} // //@objc protocol OcProtocol{ //