关于虚函数表的个人总结

最新推荐文章于 2022-08-19 17:31:23 发布
最新推荐文章于 2022-08-19 17:31:23 发布
阅读量607 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nokianasty/article/details/12178911
版权

关于虚函数表的个人总结

1.虚函数表的创建：

一个类存在虚函数的时候，编译器会为这个类创建一个虚函数表，这个表由这个类的所有对象共同所有。
在创建这个类的类对象的时候将这个对象的前4个字节作为这项这个虚函数表的指针。即类对象的首地址中的内容存放的是虚函数表的地址。
虚函数表的首地址里面存放的是第一个虚函数的首地址，如果有多个虚函数，则第二个虚函数的地址即为第一个虚函数首地址加上偏移量,
地址如果用int*为单位表示的话偏移量加1，对于以16进制位表示的话则加4,(见下例，如果看着晕的话，不用看具体的，下面会有更加详细的解释).
----(int*)*(int*)*(int*)(&b)是第一个函数的地址，则第二个函数的地址是(int*)*((int*)*(int*)(&b)+1)或者(int*)*(int*)(*(int*)(&b)+4)----
 
 

  
  

   
   

    
    

     
     ?
    
    

    
    
 
        

          1 
        
 
        

          2 
        
 
        

          3 
        
 
        

          4 
        
 
        

          5 
        
 
        

          6 
        
 
        

          7 
        
 
        

          8 
        
 
        

          9 
        
 
        

          10 
        
 
        

          11 
        
 
        

          12 
        
 
        

          13 
        
 
        

          14 
        
 
        

          15 
        
 
        

          16 
        
 
        

          17 
        
 
        

          18 
        
 
        

          19 
        
 
        

          20 
        
 
        

          21 
        
 
        

          22 
        
 
        

          23 
        
 
        

          24 
        
 
        

          25 
        
 
        

          26 
        
 
        

          27 
        
 
        
 
         
 
          #include<iostream> 
         
 
         
 
          using  
          namespace  
          std; 
         
 
         
 
          class  
          Base 
         
 
         
 
          { 
         
 
         
 
          public 
          : 
         
 
         
 
               
          virtual  
          void  
          f() 
         
 
         
 
               
          { 
         
 
         
 
                   
          cout <<  
          "Base::f"  
          << endl; 
         
 
         
 
               
          } 
         
 
         
 
               
          virtual  
          void  
          g() 
         
 
         
 
               
          { 
         
 
         
 
                   
          cout <<  
          "Base::g"  
          << endl; 
         
 
         
 
               
          } 
         
 
         
 
               
          virtual  
          void  
          h() 
         
 
         
 
               
          { 
         
 
         
 
                   
          cout <<  
          "Base::h"  
          << endl; 
         
 
         
 
               
          } 
         
 
         
 
          }; 
         
 
         
 
          int  
          main() 
         
 
         
 
          { 
         
 
         
 
               
          Base b; 
         
 
         
 
               
          Base b1; 
         
 
         
 
               
          cout<< 
          "第一个类b的地址：" 
          <<( 
          int 
          *)(&b)<<endl; 
         
 
         
 
               
          cout<< 
          "第二个类b1的地址：" 
          <<( 
          int 
          *)(&b1)<<endl; 
         
 
         
 
               
          cout<< 
          "虚地址b：" 
          <<( 
          int 
          *)*( 
          int 
          *)(&b)<<endl; 
         
 
         
 
               
          cout<< 
          "虚地址b1：" 
          <<( 
          int 
          *)*( 
          int 
          *)(&b1)<<endl; 
         
 
         
 
          } 
         
 
        

   
   

  
  


 
 

运行结果如下：



2.关于(int*)*(int*)*(int*)(&b)的解释

(int*)*(int*)*(int*)(&b)
(1)(&b)表示对对象取地址，返回的实际上是一个Base*类型的指针，也就是一个地址。
(2)(int*)(&b)强制将（Base*）类型转换成（int*）型指针，注意这里（int*）做的转换是从（Base*）到（int*）
    实际上cout<<(&b)<<endl;与cout<<(int*)(&b)<<endl;的结果是一样的实际上都是指向的同一个地址，只是指针类型不同
(3)*(int*)(&b)表示去int型指针指向地址中的内容，即虚函数表地址的16进制位数表示，现在要注意了，这里的内容实际上int型的16进制数。
(4)(int*)*(int*)(&b)的第一个(int*)表示将取到的int型地址转换成地址，即虚函数表的地址，与（2）里面的（int*）的作用不一样。
　　比如下面的几条语句：     
 
 

  
  

   
   

    
    

     
     ?
    
    

    
    
 
        

          1 
        
 
        

          2 
        
 
        

          3 
        
 
        
 
         
 
          int 
          * p; 
         
 
         
 
          //p=0x567890; 
         
 
         
 
          p=( 
          int 
          *)0x567890;

　　注释的地方是错误的关键就在于0x567890是一个十六进制数与地址无关，用(int*)可以将16进制数转化成地址，然后用指针p指向地址。

(5)*(int*)*(int*)(&b),表示取虚函数表中第一个地址中的内容，即虚函数表中存放的第一个函数的地址的十六进制数表示，是int型

(6)(int*)*(int*)*(int*)(&b),将表示第一个函数地址的16进制数转换成地址，即第一个函数的地址

(7)如果以地址为单位求下一个函数的地址则在地址后加4，如(int*)*(int*)(*(int*)(&b)+4)

　　如果以int*为单位的话求系一个函数地址则直接加1，如(int*)*((int*)*(int*)(&b)+1)

3.如何通过虚函数表进行函数调用。

现在在原来的代码中定义一个函数指针。

?
1
typedef  void (*Fun)( void ); //如果不用Fun声明p函数指针的话可以直接写麻烦的式子：void(*p)(void)=(Fun)(int*)*((int*)*(int*)(&b)+1);

在main函数中

调用函数f：

?
1
2
3
Fun p=NULL;
p=(Fun)( int *)*( int *)*( int *)(&b);
p();

调用函数g

?
1
2
p=(Fun)( int *)*(( int *)*( int *)(&b)+1); //或者p=(Fun)(int*)*(int*)(*(int*)(&b)+4);
p();

调用函数h 

?
1
2
p=(Fun)( int *)*(( int *)*( int *)(&b)+2); //或者p=(Fun)(int*)*(int*)(*(int*)(&b)+8);
p();

结果：

nokianasty
关注
C++ 多态与虚函数表（五）拓展—— 对象大小
行走
08-16 346
一、前言 前面文章中分析了对象内存布局，对象大小已经不难理解了，这里集中总结一下。 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、实例代码 2.1 代码 运行环境 64位 #include<iostream> #incl.
C++ 多态与虚函数表（四）—— 虚继承
行走
08-16 345
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、单虚继承Base1 只有一层继承关系且为虚继承，只是用于测试，实际工作中不会这么样。 2.1 类定义 class Base { public: long long ibase.
vtbl（虚函数表）与vptr（虚函数表指针）
micx0124的专栏
08-08 934
类的虚函数表是一块连续的内存，每个内存单元中记录一个JMP指令的地址   注意的是，编译器会为每个有虚函数的类创建一个虚函数表，该虚函数表将被该类的所有对象共享。类的每个虚成员占据虚函数表中的一行。如果类中有N个虚函数，那么其虚函数表将有N*4字节的大小。   虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主
c++虚函数有几个虚表
jiuzhouhi的专栏
03-07 4866
怕自己忘记了，所以复制一下，尊重他人版权，http://blog.csdn.net/haoel/article/details/1948051/ 前言   C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了
C++多态虚函数表详解(多重继承、多继承情况)
热门推荐
青城山小和尚
08-20 4万+
本文关键词：C++ 多态 虚函数表 虚函数指针 动态绑定 概述：C++相对其他面向对象语言来说，之所以灵活、高效。很大程度的占比在于其多态技术和模板技术。C++虚函数表是支撑C++多态的重要技术，它是C++动态绑定技术的核心。 本文章将着重图解虚函数表相关知识，在阅读本文前，博主已经默认你已经学习了C++多态的语法，并且通过代码实践过。
807-C++多继承下，派生类对象有几张虚函数表？
LINZEYU666的博客
11-14 2270
C++多继承下，派生类对象有几张虚函数表？ 我们看下面这个示例： #include <iostream> #include <string> #include <typeinfo> using namespace std; class Base1//基类 { public: Base1() : x(1) {} virtual void play() { cout << "Base1::play basketball" << endl; }
C++虚函数表的底层原理 & 到底有几张虚函数表？ & 虚函数表是怎么维护的？
weixin_47826078的博客
08-19 657
昨天读了陈皓前辈博客中关于虚函数表底层原理的一篇博客，本着实践出真知的出发点，遂写了相应的测试代码去检验，发现最后测试出来的结果和陈皓博客中说明的情况存在出入。目前尚不清楚是不同编译器底层实现原理不同还是整个标准已经迭代（距离那篇博客的发布时间已经过去15年了），欢迎一样有求知欲的伙伴同僚也把代码拿去测试，一起分享心得！
C++ 多态与虚函数表（二）—— 多继承
行走
08-16 394
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、多继承 2.1 类定义 class Base1 { public: long long ibase1; Base1 ():ibase1 (10) {} vir.
C++ 多态与虚函数表（一）—— 单继承
行走
08-16 1680
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、取地址 class Base { public: long long value; virtual f(); }; typedef void(*ptrType)(vo.
d3d透视逆向篇：第7课 虚表和虚函数分析
mutashizhe的博客
12-11 663
课程不能继续了，这里基础比较差的朋友，自己补充下知识。 了解：类、继承、虚函数、纯虚函数、虚表 逆向学习目的：分析虚表和虚函数地址 #include "pch.h" #include <iostream> #include "windows.h" using namespace std; class Animal { private: int height=0x8888; int...
虚函数虚表的详解，大家看看！
06-06
个类如果有虚函数，不管是几个虚函数，都会为这个类声明一个虚函数表，这个虚表是一个含有虚函数的类的，不是说是类对象的。一个含有虚函数的类，不管有多少个数据成员，每个数据成员都有一个虚指针，在内存中，存放每个类对象的内存区，在内存区的头部都是先存放这个指针变量的，从第5个字节才是这个对象自己的东西。
虚函数表
记不住
12-17 335
转自：http://www.cnblogs.com/Z465360621/articles/4561344.html  虚函数表，以及虚函数指针：  1）每个有虚函数的类都有自己的虚函数表，每个包含虚函数的类对象都有虚函数表指针。  2）对于多重继承，如果多个基类都有虚函数，则继承类中包含多个基类虚函数表，子类的虚函数地址放在声明的第一个基类虚函数表后面。  3）计算类对象的内存大小的时候，需要计...
虚函数&虚函数表&详
weixin_44179371的博客
07-03 283
本文转自：https://blog.csdn.net/lihao21/article/details/50688337关键词：虚函数，虚表，虚表指针，动态绑定，多态一、概述为了实现C++的多态，C++使用了一种动态绑定的技术。这个技术的核心是虚函数表（下文简称虚表）。本文介绍虚函数表是如何实现动态绑定的。二、类的虚表每个包含了虚函数的类都包含一个虚表。 我们知道，当一个类（A）继承另一个类（B）时，类A会继承类B的函数的调用权。所以如果一个基类包含了虚函数，那么其继承类也可调用这些虚函数，换句话说
虚函数表的问题
buki26的博客
08-22 412
虚函数表：多态是由虚函数实现的，而虚函数主要是通过虚函数表（V-Table）来实现的。如果一个类中包含虚函数（virtual修饰的函数），那么这个类就会包含一张虚函数表，虚函数表存储的每一项是一个虚函数的地址。如下图：这个类的每一个对象都会包含一个虚指针（虚指针存在于对象实例地址的最前面，保证虚函数表有最高的性能），这个虚指针指向虚函数表。注：对象不包含虚函数表，只有虚指针，类才包含虚函数表，派生类
c++中的虚函数及虚函数表
sinat_38606329的博客
07-04 991
一、虚函数的定义 有关键字virtual修饰的成员函数，为了实现多态。 二、虚函数表 1.虚函数表用来存放虚函数的地址，也称虚表。 2.一个含有虚函数的类中至少有一个虚表。 3.虚表指针：二级指针，虚函数指针的指针，存放在对象模型头部，32位系统中占4个字节，在64位系统中占8个字节。虚表指针中存放着虚表的首地址。可以通过对象实例化的地址得到虚函数表的地址。 4.虚表与虚表指针的关系如下： 三、...
关于C++中虚函数表存放位置的思考
ahuang1900的专栏
09-10 1126
原文地址：关于C++中虚函数表存放位置的思考 作者：fuliangcheng     其实这是我前一段时间思考过的一个问题，是在看《深入探索C++对象模型》这本书的时候我产生的一个疑问，最近在网上又看到类似的帖子，贴出来看看： 我看到了很多有意思的答案，都回答的比较好，下面贴出一些具有代表性的： Answer 1： Answer 2: 我们都知道，虚函数是
深入分析虚函数表
weixin_42136255的博客
03-23 1556
相关虚函数表的问题分析： (1)一个类只有包含虚函数才会存在虚函数表，同属于一个类的对象共享虚函数表，但是有各自的vptr(虚函数表指针)，当然所指向的虚函数表是同一个。 (2)父类中有虚函数就等于子类中有虚函数。只要父类中有虚函数，子类中即便不写virtual，也依旧是虚函数。 (3)不管是父类还是子类，都会只有一个虚函数表。不能认为子类继承父类，就认为子类的虚函数表就是，父类的虚函数表+...
c++虚函数表详解
qi_700的博客
11-07 1137
一、单继承和多继承 我们了解一下何为单继承，何为多继承？？ 单继承：一个子类只有一个直接父类。 多继承：一个子类有两个或多个直接父类。 二、类的虚函数表与类实例的虚函数指针 首先不考虑继承的情况。如果一个类中有虚函数，那么该类就有一个虚函数表。这个虚函数表是属于类的，所有该类的实例化对象中都会有一个虚函数表指针去指向该类的虚函数表。一个类...
C++虚函数表实现机制解析
"C++的虚函数表工作原理与应用" 虚函数表是C++实现多态性的一个关键机制，主要用于解决动态绑定问题，确保通过基类指针调用子类重写的成员函数时能正确执行子类的实现。在C++中，当一个类声明了虚函数，编译器就会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值