1.虛擬函式列表的位置

結論

編譯器一般會保證指向虛擬函式列表的指標存在於物件例項中最前面的位置

而虛擬函式列表中的內容, 就是多個函式指標

程式碼驗證:

首先宣告一個基類Base和一個派生類Derived

class  Base
{
public:
  virtual void f() { std::cout << "Base1::f" << std::endl; }
  virtual void g() { std::cout << "Base1::g" << std::endl; }
  virtual void h() { std::cout << "Base1::h" << std::endl; }
  virtual void i() { std::cout << "Base1::i" << std::endl; }
};

class Derived : public Base
{
  virtual void g() override { std::cout << "Derived::g" << std::endl; }
  virtual void h1() { std::cout << "Derived::i1" << std::endl; }
};

然後例項化一個派生類的物件

Derived derived;

現在我們打印出該物件的地址

std::cout << "derived物件的地址: " << (&derived) << std::endl;

由於我們假定指向虛擬函式列表的<指標>存在於物件例項中最前面的位置

那麼我們可以認定, derived物件的地址中的開頭是一個指標的地址(稱之為指標pA)

而這個指標(pA)指向虛擬函式列表中的開頭, 也就是一個函式指標(稱之為指標pF)

所以這個指標(pA), 是一個指向指標的指標, 即指向指標(pF)的指標(pA)

基於這個推測, 我們將derived物件的地址

即指標pA的地址進行一個型別轉換

使用reinterpret_cast<int**>關鍵字, 將其轉換為一個指向指標的指標

reinterpret_cast<int**>(&derived)

現在我們對這個指標(pA)的地址, 取其內容, 就會得到pA的內容

std::cout << "derived物件中第一個指標的內容: " << *reinterpret_cast<int**>(&derived) << std::endl;

根據上面的推測, 這個內容, 就是虛擬函式列表的地址

控制檯輸出如下:

通過vs2019中, 可以直接檢視到derived

的__vfptr物件的地址, 和控制檯列印的內容是相同的

2.單繼承中虛擬函式列表的內容

基類中有4個函式, 分別為

f(); 
g(); 
h(); 
i();

派生類中有2個函式,分別為

g();
i1();

現在使用表格的方式表示出來, 方便檢視, 進行了override的函式, 會放在同一行

結論在虛擬函式列表中, 函式的佈局如下圖所示:

程式碼驗證請看鏈式繼承中虛擬函式列表的內容

3.鏈式繼承中虛擬函式列表的內容

宣告3個類, 其繼承關係為Derived繼承Base2, Base2繼承Base1

class Base1 {
public:
  virtual void f() { std::cout << "Base1::f" << std::endl; }
  virtual void g() { std::cout << "Base1::g" << std::endl; }
  virtual void h() { std::cout << "Base1::h" << std::endl; }
  virtual void i() { std::cout << "Base1::i" << std::endl; }
};

class Base2 : public Base1{
public:
  virtual void f()override { std::cout << "Base2::f" << std::endl; }
  virtual void h1() { std::cout << "Base2::h1" << std::endl; }
};

class Derived : public Base2 {
public:
  virtual void g()override { std::cout << "Derived::g" << std::endl; }
  virtual void i1() { std::cout << "Derived::i1" << std::endl; }
};

用表格的方法表示為:

!()(https://silenzio-markdown-image-hosting-service.oss-cn-beijing.aliyuncs.com/%E5%8D%9A%E5%AE%A2%E5%9B%BE%E5%BA%8A/C%2B%2B%20%E9%93%BE%E5%BC%%E7%BB%A7%E6%89%BF%E4%B8%8B%E7%9A%84%E8%99%9A%E5%87%BD%E6%95%B0%E5%88%97%E8%A1%A8/1a885406e3318ccbbf5dce9961e1599.png)

結論

在虛擬函式列表中, 函式的佈局如下圖所示:

Derive只有一個虛擬函式表, 是在Base2的虛擬函式表上, 進行類似於單繼承的覆蓋
同理, Base2也有一張虛擬函式表, 是在Base1的虛擬函式表上, 進行單繼承的覆蓋

程式碼驗證

////////////////////////////////////////////////////////////////////////////////
// 鏈式繼承
////////////////////////////////////////////////////////////////////////////////
#include <iostream>
class Base1 {
public:
  virtual void f() { std::cout << "Base1::f" << std::endl; }
  virtual void g() { std::cout << "Base1::g" << std::endl; }
  virtual void h() { std::cout << "Base1::h" << std::endl; }
  virtual void i() { std::cout << "Base1::i" << std::endl; }
};

class Base2 : public Base1{
public:
  virtual void f()override { std::cout << "Base2::f" << std::endl; }
  virtual void h1() { std::cout << "Base2::h1" << std::endl; }
};

class Derived : public Base2 {
public:
  virtual void g()override { std::cout << "Derived::g" << std::endl; }
  virtual void i1() { std::cout << "Derived::i1" << std::endl; }
};

using Fun = void(*)(void);

int main()
{
  Fun pFun = nullptr;

  // 作業系統: windows 10 專業版 32/64位都可以
  // 編譯器 : Visual Studio 2019 Community
  std::cout << sizeof(int) << std::endl; //  32位:4  64位:4
  std::cout << sizeof(long) << std::endl; // 32位:4  64位:4
  std::cout << sizeof(int*) << std::endl; // 32位:4  64位:8

  std::cout << "-------------------------------------------------------------------------------------- " << std::endl;
  std::cout << "Base1的虛表如下 " << std::endl;
  Base1 base1;

  std::cout << "base1物件的地址: " << (&base1) << std::endl;
  std::cout << "base1物件中第一個指標的地址(不是內容): " << (&base1) << std::endl;
  // &base1 是一個指向指標的指標
  // 對它進行*操作, 得到了這個指標的內容, 即它指向的位置, 是一個虛表(虛表的內容也是一堆指標)
  std::cout << "base1物件中第一個指標的內容: " << *reinterpret_cast<int**>(&base1) << std::endl;
  std::cout << "base1虛擬函式表地址: " << *reinterpret_cast<int**>(&base1) << std::endl;
  
  // 虛擬函式表地址, 也是一個指向指標的指標
  // 對它進行*操作, 得到了這個指標的內容, 即它指向的位置, 是一個函式指標
  std::cout << "base1虛擬函式表 — 第一個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1))))) << std::endl;
  pFun = reinterpret_cast<Fun>(* (reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1)))));
  std::cout << "base1虛擬函式表 — 第一個函式內容：";
  pFun();                        // base1::f
  std::cout << std::endl;

  // 注意次數的偏移量, 32位偏移量是+1, 64位偏移量是+2
  std::cout << "base1虛擬函式表 — 第二個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1))+1*(sizeof(int*)/sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1)) + 1 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base1虛擬函式表 — 第二個函式內容：";
  pFun();                        // base1::g
  std::cout << std::endl;

  std::cout << "base1虛擬函式表 — 第三個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1)) + 2 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1)) + 2 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base1虛擬函式表 — 第三個函式內容：";
  pFun();                        // base1::h
  std::cout << std::endl;

  std::cout << "base1虛擬函式表 — 第四個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1)) + 3 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base1)) + 3 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base1虛擬函式表 — 第四個函式內容：";
  pFun();                        // base1::i
  std::cout << std::endl;

  std::cout << "-------------------------------------------------------------------------------------- " << std::endl;
  std::cout << "Base2的虛表如下 " << std::endl;
  Base2 base2;

  std::cout << "base2物件的地址: " << (&base2) << std::endl;
  std::cout << "base2物件中第一個指標的地址(不是內容): " << (&base2) << std::endl;
  // &base1 是一個指向指標的指標
  // 對它進行*操作, 得到了這個指標的內容, 即它指向的位置, 是一個虛表(虛表的內容也是一堆指標)
  std::cout << "base2物件中第一個指標的內容: " << *reinterpret_cast<int**>(&base2) << std::endl;
  std::cout << "base2虛擬函式表地址: " << *reinterpret_cast<int**>(&base2) << std::endl;

  // 虛擬函式表地址, 也是一個指向指標的指標
  // 對它進行*操作, 得到了這個指標的內容, 即它指向的位置, 是一個函式指標
  std::cout << "base2虛擬函式表 — 第一個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)))));
  std::cout << "base2虛擬函式表 — 第一個函式內容：";
  pFun();                        // base2::f
  std::cout << std::endl;

  std::cout << "base2虛擬函式表 — 第二個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 1 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 1 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base2虛擬函式表 — 第二個函式內容：";
  pFun();                        // base1::g
  std::cout << std::endl;

  std::cout << "base2虛擬函式表 — 第三個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 2 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 2 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base2虛擬函式表 — 第三個函式內容：";
  pFun();                        // base1::h
  std::cout << std::endl;

  std::cout << "base2虛擬函式表 — 第四個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 3 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 3 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base2虛擬函式表 — 第四個函式內容：";
  pFun();                        // base1::i
  std::cout << std::endl;

  std::cout << "base2虛擬函式表 — 第五個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 4 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&base2)) + 4 * (sizeof(int*) / sizeof(int)))));
  std::cout << "base2虛擬函式表 — 第五個函式內容：";
  pFun();                        // base2::h1
  std::cout << std::endl;

  std::cout << "-------------------------------------------------------------------------------------- " << std::endl;
  std::cout << "Derived的虛表如下 " << std::endl;
  Derived Derived;

  std::cout << "Derived物件的地址: " << (&Derived) << std::endl;
  std::cout << "Derived物件中第一個指標的地址(不是內容): " << (&Derived) << std::endl;
  // &base1 是一個指向指標的指標
  // 對它進行*操作, 得到了這個指標的內容, 即它指向的位置, 是一個虛表(虛表的內容也是一堆指標)
  std::cout << "Derived物件中第一個指標的內容: " << *reinterpret_cast<int**>(&Derived) << std::endl;
  std::cout << "Derived虛擬函式表地址: " << *reinterpret_cast<int**>(&Derived) << std::endl;

  // 虛擬函式表地址, 也是一個指向指標的指標
  // 對它進行*操作, 得到了這個指標的內容, 即它指向的位置, 是一個函式指標
  std::cout << "Derived虛擬函式表 — 第一個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)))));
  std::cout << "Derived虛擬函式表 — 第一個函式內容：";
  pFun();                        // base2::f
  std::cout << std::endl;

  std::cout << "Derived虛擬函式表 — 第二個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 1 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 1 * (sizeof(int*) / sizeof(int)))));
  std::cout << "Derived虛擬函式表 — 第二個函式內容：";
  pFun();                        // Derived::g
  std::cout << std::endl;

  std::cout << "Derived虛擬函式表 — 第三個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 2 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 2 * (sizeof(int*) / sizeof(int)))));
  std::cout << "Derived虛擬函式表 — 第三個函式內容：";
  pFun();                        // base1::h
  std::cout << std::endl;

  std::cout << "Derived虛擬函式表 — 第四個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 3 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 3 * (sizeof(int*) / sizeof(int)))));
  std::cout << "Derived虛擬函式表 — 第四個函式內容：";
  pFun();                        // base1::i
  std::cout << std::endl;

  std::cout << "Derived虛擬函式表 — 第五個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 4 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 4 * (sizeof(int*) / sizeof(int)))));
  std::cout << "Derived虛擬函式表 — 第五個函式內容：";
  pFun();                        // base2::h1
  std::cout << std::endl;

  std::cout << "Derived虛擬函式表 — 第六個函式地址：" << (*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 5 * (sizeof(int*) / sizeof(int))))) << std::endl;
  pFun = reinterpret_cast<Fun>(*(reinterpret_cast<int**>(*(reinterpret_cast<int**>(&Derived)) + 5 * (sizeof(int*) / sizeof(int)))));
  std::cout << "Derived虛擬函式表 — 第六個函式內容：";
  pFun();                        // Derived::i1
  std::cout << std::endl;

  return 0;
} 
 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    C++ 鏈式繼承下的虛擬函式列表
      目錄
1.虛擬函式列表的位置
2.虛擬函式列表的內容
3.鏈式繼承中虛擬函式列表的內容
 
注:
虛擬函式列表 又稱為虛表, vtbl , 指向它的指標稱為vptr, vs2019中稱為__vfptr
作業系統: windows 10 專業版 64位
編譯器: Visual Studio 2019  

  
 

    

    
    【C++】在繼承中虛擬函式、純虛擬函式、普通函式，三者的區別
       
 
 1.虛擬函式(impure virtual) 
 　　C++的虛擬函式主要作用是“執行時多型”，父類中提供虛擬函式的實現，為子類提供預設的函式實現。 
 　　子類可以重寫父類的虛擬函式實現子類的特殊化。 
 　　如下就是一個父類中的虛擬函式： 
 class A
{
public:
    virt 

  
 

    

    
    C++記憶體分佈之菱形繼承(無虛擬函式)
      
                
       菱形繼承的定義是：兩個子類繼承同一父類，而又有子類同時繼承這兩個子類。例如a,b兩個類同時繼承c，但是又有一個d類同時繼承a,b類。探究的過程還是很有趣的。 菱形繼承的記憶體佈局探究花了我幾天時間，探究起來還是有點難度的。博文中如果有錯誤的地方，歡迎大家指正， 

  
 

    

    
    【C++】C++類的學習（四）——繼承與虛擬函式
      
                



前言

      面向物件程式設計的核心思想是資料抽象、繼承和動態繫結（也稱之為動態聯編）。通過資料抽象將類的介面與實現分離；使用繼承可以定義相似的型別並對相似的關係建模；使用動態繫結可以在一定程度上忽視型別的區別，使用統一的方式使用他們的物件。

      類是 

  
 

    

    
    C++ 在繼承中虛擬函式、純虛擬函式、普通函式，三者的區別【轉載】
      
                

1.虛擬函式(impure virtual)

　　C++的虛擬函式主要作用是“執行時多型”，父類中提供虛擬函式的實現，為子類提供預設的函式實現。

　　子類可以重寫父類的虛擬函式實現子類的特殊化。

　　如下就是一個父類中的虛擬函式：

class A
{
public 

  
 

    

    
    C++繼承、虛繼承、虛擬函式類的大小問題
      
                

一、真空類

class CNull
{
};

長度：1
記憶體結構：

??

評註：長度其實為0，這個位元組作為內容沒有意義，可能每次都不一樣。

二、空類

class CNull2
{
public:
    CNull2(){printf("Construct 

  
 

    

    
    C++ 在繼承中虛擬函式、純虛擬函式、普通函式，三者的區別
      
                

1.虛擬函式(impure virtual)

　　C++的虛擬函式主要作用是“執行時多型”，父類中提供虛擬函式的實現，為子類提供預設的函式實現。

　　子類可以重寫父類的虛擬函式實現子類的特殊化。

　　如下就是一個父類中的虛擬函式：


class A
{
publi 

  
 

    

    
    Oracle 12c 插鏈式資料庫下建表空間，新建使用者及賦權SQL，解決空表導不出的問題，使用者鎖定問題，密碼過期問題。
       
 
 
 
 1、連線SQLPLUS
 sqlplus /nolog
 
 2、SYSDBA登入
 conn / as sysdba
 
 3、檢視PDB
 show pdbs;
 
 4、將會話轉到具體某個DB下
 alter session set container=dbname;
 
 5、建立表 

  
 

    

    
    c語言實現linux下高危函式system （簡易V1.0版本）
       
  
  
 system這個函式真的是要慎用，一不小心就會留下漏洞。 
 下面是用c語言簡易的實現了一下system函式 
 #include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<err 

  
 

    

    
    ThinkPHP通過類的鏈式繼承優化空操作的實現
       
 
 在處理空操作時修改了父類Controller.class.php中程式碼，不到萬不得已不能 
 修改基類控制器中的原碼，此時可在子類與父類之間，建立一箇中間控制器CommonController.class.php通過鏈式繼承來實現。 
  
 此時先刪除先前基類Controller.class.p 

  
 

    

    
    C++物件模型中的虛擬函式分析
       
 
 對於虛擬函式，知道它的含義，也能夠描述出來。參照百度百科，也就是“它提供了‘動態繫結’機制”。 
 可總是感覺有些迷糊，於是敲了一段程式碼出來試驗，一探究竟（程式設計環境是VC6.0）。對比程式碼和結果，一切都不言自明。 
 現在把程式碼和結果貼上來，作為儲存記錄，同時也歡迎大家提出意見，以臻完善。 

  
 

    

    
    二叉樹的鏈式儲存及其部分函式實現
       
 
 題意 
 實現二叉樹的鏈式儲存和部分的函式 
 思路 
 這是一個鏈式儲存實現的二叉樹。首先 是構造了一個名為 node 的 二叉樹資料結構內有（1）char 變數，（2）兩個指向其本身的結構體指標變數 lch,rch.然後 用typedef分別給 node結構體起了一個Bn的別名和給 node*  

  
 

    

    
    c++子類繼承父類函式呼叫特性原理以及與java的對比
       
 
 
 c++ 
 
  c++中子類繼承了父類，子類物件的函式和變數會接著新增在父類物件的記憶體後面，以此類推。。。 
  如果c++中父類的那個變數或者函式宣告為virtual虛擬函式，那麼子類物件的同名函式就直接覆蓋了（即在記憶體中真正的覆蓋，父類的這個函式已經不在了）父類物件的這個函式 
  如 

  
 

    

    
    第四章——64位軟體逆向技術-基本語法（下 虛擬函式）
      
 虛擬函式
 

    VC++實現虛擬函式的方式就是虛表，如果一個類至少要有一個虛擬函式，編譯器會為這個類產生一個虛表。不同的類虛表就不同，相同的類虛表就會共享
 

     識別構造和析構 如果在函式入口有 lea reg,off_xxxx 

  
 

    

    
    虛繼承、虛擬函式
      
                1. 虛繼承簡單的說就是如果有兩個類都繼承了同一個基類（A），那麼，如果有第三個類又繼承了這兩個類，第三個類就會出現有      兩個基類（A）的情況，虛繼承就能避免這種情況。

    從實現程式碼來看：

    普通繼承：

/**
	普通繼承（沒有使用虛基類）
*/
 

  
 

    

    
    C++中多型和虛擬函式怎麼回答
      
                1.定義：

      多型性可以簡單地概括為“一個介面，多種方法”，程式在執行時才決定呼叫的函式，它是面向物件程式設計領域的核心概念。多型(polymorphism)，字面意思多種形狀。
　　C++多型性是通過虛擬函式來實現的，虛擬函式允許子類重新定義成員函式，而子類重新 

  
 

    

    
    c語言實現linux下高危函式system  （簡易V1.0版本）
      
							
							
							system這個函式真的是要慎用，一不小心就會留下漏洞。
下面是用c語言簡易的實現了一下system函式
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#inc 

  
 

    

    
    kotlin 複合函式 函式鏈式呼叫 以及偏函式
      
							
							
							package kotlinall.chapter5

import java.io.OutputStream
import java.nio.charset.Charset

//複合函式
//求f(g(x))的值
val add5={i:Int->i+ 

  
 

    

    
    C++多型：深入虛擬函式，理解晚繫結
      
							
							
							 C++的多型特性是通過晚繫結實現的。晚繫結（late binding），指的是編譯器或直譯器程式在執行前，不知道物件的型別。使用晚繫結，無需檢查物件的型別，只需要檢查物件是否支援特性和方法即可。 
 在C++中，晚繫結通常發生在使用virtual宣告成員函式時 

  
 

    

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

C++ 鏈式繼承下的虛擬函式列表

目錄