2. 程式人生 > >虛擬函式表分析

虛擬函式表分析

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

0.多型

C++幾個的抽象、封裝、繼承和多型幾大特性當中，多型是最為重要的一個。所謂多型(這裡指狹義的多型)就是父類指標或引用指向子類物件，然後可以通過父類指標或引用呼叫子類的成員函式。 剛開始學習多型的時候，覺得多型非常神奇，同時也非常費解。後來瞭解到c++的多型是通過虛擬函式表來實現的，但是一直也沒有做一個系統的總結。今天寫幾個例子梳理一下c++是怎麼通過虛擬函式表來實現多型的。

1. 單繼承虛擬函式表

例1

#include<iostream>
using namespace std;
class A {
    private:
        int  a;
    public:
        virtual void f() {
            cout<<"A::f()"<<endl;
        }
        virtual void g() {
            cout<<"A::g()"<<endl;
        }
};
class B:public A {
    private:
        int b;
    public:
        virtual void f() {
            cout<<"B::f()"<<endl;   
        }
        virtual void g1() {
            cout<<"B::g1()"<<endl;
        }
        void h() {
            cout<<"B::h()"<<endl;
        }
};
int main()
{
    typedef void(*fun)(void);
    fun pFun;
    A a;
    B b;
    return 0;
}

定義了兩個物件，B繼承自A。 B重寫了A的f()函式，並新增了一個虛成員函式g1()和一個普通的成員函式h()。那麼物件a，b的記憶體佈局應該如下圖所示：

在這裡插入圖片描述
口說無憑，我們用gdb列印一下看看。

$ gdb a.exe
GNU gdb (GDB) 7.6.1
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "mingw32".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from F:\zkangHUST\C++\a.exe...done.
(gdb) start
Temporary breakpoint 1 at 0x40146e: file test3.cpp, line 32.
Starting program: F:\zkangHUST\C++/a.exe
[New Thread 10860.0x2e0c]
[New Thread 10860.0x3e64]
[New Thread 10860.0x3e94]
[New Thread 10860.0x8]

Temporary breakpoint 1, main () at test3.cpp:32
32          A a;
(gdb) n
33          B b;
(gdb)
51          return 0;
(gdb) p a
$1 = {_vptr.A = 0x405178 <vtable for A+8>, a = 4194432}
(gdb) p (int*)*((int*)0x405178)
$2 = (int *) 0x403c08 <A::f()>
(gdb) p (int*)*((int*)0x405178 + 1)
$3 = (int *) 0x403c3c <A::g()>
(gdb) p (int*)*((int*)0x405178 + 2)
$4 = (int *) 0x0
(gdb) p b
$5 = {<A> = {_vptr.A = 0x405188 <vtable for B+8>, a = 4200896}, b = 0}
(gdb) p (int*)*((int*)0x405188)
$6 = (int *) 0x403ca0 <B::f()>
(gdb) p (int*)*((int*)0x405188+1)
$7 = (int *) 0x403c3c <A::g()>
(gdb) p (int*)*((int*)0x405188+2)
$8 = (int *) 0x403cd4 <B::g1()>
(gdb) p (int*)*((int*)0x405188+3)
$9 = (int *) 0x3a434347
(gdb)

在這裡插入圖片描述
說明一下 ，gdb中執行 p A的結果是

(gdb) p a
$1 = {_vptr.A = 0x405178 <vtable for A+8>, a = 4194432}
(gdb) p (int*)*((int*)0x405178)
$2 = (int *) 0x403c08 <A::f()>

a的虛擬函式表地址是0x405178，把這個地址強制轉換成int指標,對改指標取值即是虛擬函式表第一個函式的地址，可以轉換成int指標，打印出來。可以看到，虛擬函式表跟我們分析的是一樣的。這裡有一個問題，可以看到A的虛擬函式表是以空地址結束的，B的虛擬函式結束的位置是一個隨機值，可見虛擬函式表並不一定是以空地址結束。另外，B類新增的h()函式沒有加入到虛擬函式表中，因為它不是一個虛擬函式，這個函式怎麼呼叫已經在程式編譯的過程中確定了(即所謂靜態聯編，也叫早期聯編)。
同理，如果有第三個類C像下面這樣繼承類B。

class C:public B {
    private:
        int c;
    public:
        virtual void f() {
            cout<<"C::f()"<<endl;   
        }
        virtual void g1() {
            cout<<"C::g1()"<<endl;
        }
        virtual void k() {
            cout<<"C::k()"<<endl;
        }
};

那麼C物件的記憶體應該如下圖:
在這裡插入圖片描述

int main()
{
    A a;
    B b;
    C c;
    return 0;
}

gdb列印結果如下：

(gdb) p c
$1 = {<B> = {<A> = {_vptr.A = 0x4051c0 <vtable for C+8>, a = 1948871853}, b = 4200912}, c = 6422368}
(gdb) p (int*)*((int*)0x4051c0)
$2 = (int *) 0x403d58 <C::f()>
(gdb) p (int*)*((int*)0x4051c0 + 1)
$3 = (int *) 0x403c4c <A::g()>
(gdb) p (int*)*((int*)0x4051c0 + 2)
$4 = (int *) 0x403dc0 <C::g1()>
(gdb) p (int*)*((int*)0x4051c0 + 3)
$5 = (int *) 0x403d8c <C::k()>
(gdb) p (int*)*((int*)0x4051c0 + 4)
$6 = (int *) 0x3a434347

在這裡插入圖片描述

2. 多繼承（無虛擬函式覆蓋）

單繼承的虛擬函式表比較簡單，現在來看下多繼承的虛擬函式表是什麼樣的。首先看多繼承無虛擬函式覆蓋的情況。假設有四個類A,B,C,D。繼承關係如下圖。
在這裡插入圖片描述

程式碼如下：

class A {
    private:
        int  a;
    public:
        virtual void f() {
            cout<<"A::f()"<<endl;
        }
        virtual void g() {
            cout<<"A::g()"<<endl;
        }
};
class B {
    private:
        int a;
    public:
        virtual void f() {
            cout<<"B::f()"<<endl;   
        }
        virtual void g() {
            cout<<"B::g()"<<endl;
        }
};
class C {
    private:
        int a;
    public:
        virtual void f() {
            cout<<"C::f()"<<endl;   
        }
        virtual void g() {
            cout<<"C::g1()"<<endl;
        }
};
class D:public A,public B, public C {
    private:
        int a;
    public:
       virtual void h() {
           cout<<"D::h()"<<endl;
       }
};

子類繼承了多個父類，在記憶體中會維持多張虛擬函式表，有幾個父類就有幾張虛擬函式表。同時，自己新加的虛擬函式會附加到第一個父類的虛擬函式表後面。類D的記憶體佈局如圖：

在這裡插入圖片描述
gdb 列印的結果是：

(gdb) p d
$1 = {<A> = {_vptr.A = 0x4051f0 <vtable for D+8>, a = 6422368}, <B> = {_vptr.B = 0x405204 <vtable for D+28>, a = 4200896}, <C> = {
    _vptr.C = 0x405214 <vtable for D+44>, a = 3981312}, a = 4194432}
(gdb) p (int*)*((int*)0x4051f0)
$2 = (int *) 0x403c08 <A::f()>
(gdb) p (int*)*((int*)0x4051f0 + 1)
$3 = (int *) 0x403c3c <A::g()>
(gdb) p (int*)*((int*)0x4051f0 + 2)
$4 = (int *) 0x403d88 <D::h()>
(gdb) p (int*)*((int*)0x4051f0 + 3)
$5 = (int *) 0xfffffff8
(gdb) p (int*)*((int*)0x405204)
$6 = (int *) 0x403c88 <B::f()>
(gdb) p (int*)*((int*)0x405204 + 1)
$7 = (int *) 0x403cbc <B::g()>
(gdb) p (int*)*((int*)0x405204 + 2)
$8 = (int *) 0xfffffff0
(gdb) p (int*)*((int*)0x405214)
$9 = (int *) 0x403d08 <C::f()>
(gdb) p (int*)*((int*)0x405214 + 1)
$10 = (int *) 0x403d3c <C::g()>
(gdb) p (int*)*((int*)0x405214 + 2)
$11 = (int *) 0x3a434347
(gdb)

相關推薦

虛擬函式表分析

0.多型 C++幾個的抽象、封裝、繼承和多型幾大特性當中，多型是最為重要的一個。所謂多型(這裡指狹義的多型)就是父類指標或引用指向子類物件，然後可以通過父類指標或引用呼叫子類的成員函式。 剛開始學習多型的時候，覺得多型非常神奇，同時也非常費解。後來瞭解到c++的多型是通過虛擬函式表來

C++單繼承、多繼承情況下的虛擬函式表分析

C++的三大特性之一的多型是基於虛擬函式實現的，而大部分編譯器是採用虛擬函式表來實現虛擬函式，虛擬函式表（VTAB）存在於可執行檔案的只讀資料段中，指向VTAB的虛表指標（VPTR）是包含在類的每一個例項當中。當使用引用或指標呼叫虛擬函式時，首先通過VPTR找到VTAB，然後通過偏移量找到虛擬函式地址並呼叫。

C++虛擬函式表例項分析

我們先來看看程式碼： #include <iostream> using namespace std; class Base {public:    virtual void f() {cout<<"base::f"<<endl;}  &

繼承裡既有虛繼承也有虛擬函式繼承（即既有虛基表，也有虛擬函式表）

對於單一的虛繼承可參考這篇部落格： https://blog.csdn.net/sophia__yu/article/details/82791522 對於有虛擬函式繼承可參考這篇部落格： https://blog.csdn.net/sophia__yu/article/details/82

C++虛擬函式表以及記憶體對齊文章

C++虛擬函式表以及記憶體對齊文章 C++ 物件的記憶體佈局(上) https://blog.csdn.net/haoel/article/details/3081328 C++ 物件的記憶體佈局(下) https://blog.csdn.net/haoel/article/deta

C++物件記憶體模型2 （虛擬函式，虛指標，虛擬函式表）

C++物件記憶體模型2 （虛擬函式，虛指標，虛擬函式表） 從例子入手，考察如下帶有虛擬函式的類的物件記憶體模型： class A { public: virtual void vfunc1(); virtual void vfunc2(); void func1();

【轉】C++虛擬函式表

引言 C++中的虛擬函式的作用主要是實現了多型的機制。關於多型，簡而言之就是用父類型別的指標指向其子類的例項，然後通過父類的指標呼叫實際子類的成員函式。這種技術可以讓父類的指標有“多種形態”，這是一種泛型技術。所謂泛型技術，說白了就是試圖使用不變的程式碼來實現可變的演算法。比如：模板技術，RTTI技術，虛擬函

C++多型呼叫實現原理（虛擬函式表詳解)

1.帶有虛擬函式的基類物件模型 我們先看段程式碼： #include<iostream> using namespace std; class B1 { public: void func1() {} int _b; }; class B2 { pub

C++多型，虛擬函式，虛擬函式表，純虛擬函式

1、多型性   指相同物件收到不同訊息或不同物件收到相同訊息時產生不同的實現動作。   C++支援兩種多型性：編譯時多型性，執行時多型性。    a、編譯時多型性：通過過載函式實現 ，模板(2次編譯)   b、執行時多型性：通過

C++虛擬函式表在虛繼承和繼承中的差別

下面的程式碼在gcc和VC中的結果 #include <cstdio> class A { public: virtual void funcaa() { printf("class A %s\n",__func__); } }; class AA:virtual pu

C++通過虛擬函式表呼叫虛擬函式

    C++的類如果有虛擬函式，則該類的第一個成員的數值，是一個地址，指向其虛擬函式表。例如     class CTest { public: virtual void Test1(void) { cout<&l

虛擬函式表存放在哪裡

1.虛擬函式表是全域性共享的元素,即全域性僅有一個. 2.虛擬函式表類似一個數組,類物件中儲存vptr指標,指向虛擬函式表.即虛擬函式表不是函式,不是程式程式碼,不肯能儲存在程式碼段. 3.虛擬函式表儲存虛擬函式的地址,即虛擬函式表的元素是指向類成員函式的指標,而類中虛擬

(C/C++學習筆記)4.C++類中的虛擬函式表Virtual Table

1 #include <iostream> 2 using namespace std; 3 4 class base 5 { 6 public: 7 virtual void f(){cout<<"base::f()"<<endl;}

C++虛擬函式表（含測試程式碼）

自己搞不懂C++虛擬函式之間的呼叫關係，特地花費一個下午加一個晚上查資料學習，現在把學到的發上來，供大家學習批評； 在此之前感謝這些大佬的部落格等，為我解惑甚多： 1、虛表與虛表指標 C++中的虛擬函式的實現一般是通過虛擬函式表（V-Table）來實

C/C++雜記：虛擬函式的實現的基本原理 虛擬函式表

部落格園 首頁 新隨筆 聯絡 訂閱 管理 1. 概述 簡單地說，每一個含有虛擬函式（無論是其本身的，還是繼承而來的）的類都至少有一個與之對應的虛擬函式表，其中存放著該類所有的虛擬函式對應的函式指標。例： 其中： B的虛擬函式表中存放著B::fo

C++ 虛擬函式表解析

1 前言 C++中的虛擬函式的作用主要是實現了多型的機制。關於多型，簡而言之就是用父型別的指標指向其子類的例項，然後通過父類的指標呼叫實際子類的成員函式。這種技術可以讓父類的指標有“多種形態”，這是一種泛型技術。所謂泛型技術，說白了就是試圖使用不變的程式碼來實現

C++ 虛擬函式表指標以及虛擬函式指標的確定

【摘要】 很多教材上都有介紹到虛指標、虛擬函式與虛擬函式表，有的說類物件共享一個虛擬函式表，有的說，一個類物件擁有一個虛擬函式表；還有的說，無論使用者聲明瞭多少個類物件，但是，這個VTABLE虛擬函式表只有一個；也有的在說，每個具有虛擬函式的類的物件裡面都有一

C++多型性與虛擬函式表

C++多型的實現 多型分為靜態多型和動態多型。靜態多型是通過過載和模板技術實現，在編譯的時候確定。動態多型通過虛擬函式和繼承關係來實現，執行動態繫結，在執行的時候確定。動態多型實現有幾個條件： （1）多型分為靜態多型和動態多型。靜態多型是通過過載和模板技術實現的，在編譯的時候確定。動態多

【C++】c++單繼承、多繼承、菱形繼承記憶體佈局（虛擬函式表結構）

單繼承：只有一個基類和一個派生類 class Base { public: virtual void fun1() { cout << "Base::func1()" << endl;

C++ 類的儲存方式以及虛擬函式表

一、C++成員函式在記憶體中的儲存方式 　　用類去定義物件時，系統會為每一個物件分配儲存空間。如果一個類包括了資料和函式，要分別為資料和函式的程式碼分配儲存空間。按理說，如果用同一個類定義了10個物件，那麼就需要分別為10個物件的資料和函式程式碼分配儲存單元，如下圖所示。