反汇编 之 virtual-06 单类继承重写虚函数

最新推荐文章于 2024-04-19 13:00:06 发布
最新推荐文章于 2024-04-19 13:00:06 发布
阅读量188 收藏
点赞数
分类专栏： C/C++ Assembly 文章标签： c++
ac
本文链接：https://blog.csdn.net/xiaozhiwise/article/details/123451823
版权
Assembly 同时被 2 个专栏收录
527 篇文章 3 订阅
订阅专栏
C/C++
86 篇文章 1 订阅
订阅专栏

#include <iostream>
#include <stdio.h>

class Base
{
    public:
        virtual void function_1()
        {
            printf("Base function_1...\n");
        }

        virtual void function_2()
        {
            printf("Base function_2...\n");
        }
    
        virtual void function_3()
        {
            printf("Base function_3...\n");
        }
};

class Sub : Base
{
    public:
        virtual void function_1()
        {
            printf("Sub function_1...\n");
        }

        virtual void function_2()
        {
            printf("Sub function_2...\n");
        }
    
        virtual void function_6()
        {
            printf("Sub function_6...\n");
        }
};

int main(int argc, char ** argv)
{
    Sub sub;

    printf("sizeof = %ld\n",  sizeof(class Base));        /* 4 */
    printf("sizeof = %ld\n",  sizeof(class Sub));        /* 4 */

    printf("sub address is %x.\n", &sub);        // this 指针，是堆栈里面的地址。虚表的地址不是this指针，是this指针的前四个字节。
    printf("sub virtual table address is:%x\n", *(int*)&sub);       // 虚表地址。取this指针的前4个字节。*(char*)&base为取一个字节。    

    typedef void(*pfunction)(void);
    
    pfunction pf;

    int temp = *((int*)(*(int*)&sub) + 0);        // 取地址表里面的第一个值
                            // *(int*)&sub) 是虚表地址
                            // (int*) 转换成一个int*类型。
                            // *((int*)(*(int*)&sub) + 0)， 加的是0，即取第一个4字节值。
    pf = (pfunction)*((int*)(*(int*)&sub) + 0);    // 或这样，取地址表里面的第一个值
    pf();                        // function_1

    pf = (pfunction)*((int*)(*(int*)&sub) + 1);    // 取第二个4字节值
    pf();                        // function_2

    for (int i = 0; i < 4; i++) {
        pf = (pfunction)*((int*)(*(int*)&sub) + i);
        pf();
    }
}

/*
     sub:function_1
    sub:function_2
    base:function_3
    sub:function_6
 
 */

#if 0

1.有重写关系。

sub对象

    ---------------            -----------------
    | 0x123245    |    --------->        | 0x123456    |    sub:function_1
    ---------------            -----------------
    | ....        |            | 0x123457    |    sub:function_2
    ---------------            -----------------
    | ....          |            | 0x123458    |    Base:function_3
    ---------------            -----------------
    | ....        |            | 0x123457    |    Sub:function_6
    ---------------            -----------------
    | ....          |            | 0x123457    |    
    ---------------            -----------------
    | 其它成员     |            | 0x123457    |    
    ---------------            -----------------
    | ....          |            | 0x000000    |
    ---------------            -----------------

int main(int argc, char ** argv)
{
 80486b0:    55                       push   %ebp
 80486b1:    89 e5                    mov    %esp,%ebp
 80486b3:    83 e4 f0                 and    $0xfffffff0,%esp
 80486b6:    83 ec 20                 sub    $0x20,%esp
    Sub sub;
 80486b9:    8d 44 24 10              lea    0x10(%esp),%eax
 80486bd:    89 04 24                 mov    %eax,(%esp)
 80486c0:    e8 a3 01 00 00           call   8048868 <_ZN3SubC1Ev>

    printf("sizeof = %ld\n",  sizeof(class Base));        /* 4 */
 80486c5:    c7 44 24 04 04 00 00     movl   $0x4,0x4(%esp)
 80486cc:    00
 80486cd:    c7 04 24 93 89 04 08     movl   $0x8048993,(%esp)
 80486d4:    e8 a7 fe ff ff           call   8048580 <printf@plt>
    printf("sizeof = %ld\n",  sizeof(class Sub));        /* 4 */
 80486d9:    c7 44 24 04 04 00 00     movl   $0x4,0x4(%esp)
 80486e0:    00
 80486e1:    c7 04 24 93 89 04 08     movl   $0x8048993,(%esp)
 80486e8:    e8 93 fe ff ff           call   8048580 <printf@plt>

    printf("sub address is %x.\n", &sub);        // this 指针，是堆栈里面的地址。虚表的地址不是this指针，是this指针的前四个字节。
 80486ed:    8d 44 24 10              lea    0x10(%esp),%eax
 80486f1:    89 44 24 04              mov    %eax,0x4(%esp)
 80486f5:    c7 04 24 a1 89 04 08     movl   $0x80489a1,(%esp)
 80486fc:    e8 7f fe ff ff           call   8048580 <printf@plt>
    printf("sub virtual table address is:%x\n", *(int*)&sub);       // 虚表地址。取this指针的前4个字节。*(char*)&base为取一个字节。    
 8048701:    8d 44 24 10              lea    0x10(%esp),%eax
 8048705:    8b 00                    mov    (%eax),%eax
 8048707:    89 44 24 04              mov    %eax,0x4(%esp)
 804870b:    c7 04 24 b8 89 04 08     movl   $0x80489b8,(%esp)
 8048712:    e8 69 fe ff ff           call   8048580 <printf@plt>

    typedef void(*pfunction)(void);
    
    pfunction pf;

    int temp = *((int*)(*(int*)&sub) + 0);        // 取地址表里面的第一个值
 8048717:    8d 44 24 10              lea    0x10(%esp),%eax
 804871b:    8b 00                    mov    (%eax),%eax
 804871d:    8b 00                    mov    (%eax),%eax
 804871f:    89 44 24 18              mov    %eax,0x18(%esp)
                            // *(int*)&sub) 是虚表地址
                            // (int*) 转换成一个int*类型。
                            // *((int*)(*(int*)&sub) + 0)， 加的是0，即取第一个4字节值。
    pf = (pfunction)*((int*)(*(int*)&sub) + 0);    // 或这样，取地址表里面的第一个值
 8048723:    8d 44 24 10              lea    0x10(%esp),%eax
 8048727:    8b 00                    mov    (%eax),%eax
 8048729:    8b 00                    mov    (%eax),%eax
 804872b:    89 44 24 14              mov    %eax,0x14(%esp)
    pf();                        // function_1
 804872f:    8b 44 24 14              mov    0x14(%esp),%eax
 8048733:    ff d0                    call   *%eax

    pf = (pfunction)*((int*)(*(int*)&sub) + 1);    // 取第二个4字节值
 8048735:    8d 44 24 10              lea    0x10(%esp),%eax
 8048739:    8b 00                    mov    (%eax),%eax
 804873b:    83 c0 04                 add    $0x4,%eax
 804873e:    8b 00                    mov    (%eax),%eax
 8048740:    89 44 24 14              mov    %eax,0x14(%esp)
    pf();                        // function_2
 8048744:    8b 44 24 14              mov    0x14(%esp),%eax
 8048748:    ff d0                    call   *%eax

    for (int i = 0; i < 4; i++) {
 804874a:    c7 44 24 1c 00 00 00     movl   $0x0,0x1c(%esp)
 8048751:    00
 8048752:    eb 24                    jmp    8048778 <main+0xc8>
        pf = (pfunction)*((int*)(*(int*)&sub) + i);
 8048754:    8b 44 24 1c              mov    0x1c(%esp),%eax
 8048758:    8d 14 85 00 00 00 00     lea    0x0(,%eax,4),%edx
 804875f:    8d 44 24 10              lea    0x10(%esp),%eax
 8048763:    8b 00                    mov    (%eax),%eax
 8048765:    01 d0                    add    %edx,%eax
 8048767:    8b 00                    mov    (%eax),%eax
 8048769:    89 44 24 14              mov    %eax,0x14(%esp)
        pf();
 804876d:    8b 44 24 14              mov    0x14(%esp),%eax
 8048771:    ff d0                    call   *%eax
    pf();                        // function_1

    pf = (pfunction)*((int*)(*(int*)&sub) + 1);    // 取第二个4字节值
    pf();                        // function_2

    for (int i = 0; i < 4; i++) {
 8048773:    83 44 24 1c 01           addl   $0x1,0x1c(%esp)
 8048778:    83 7c 24 1c 03           cmpl   $0x3,0x1c(%esp)
 804877d:    7e d5                    jle    8048754 <main+0xa4>
        pf = (pfunction)*((int*)(*(int*)&sub) + i);
        pf();
    }
}
 804877f:    b8 00 00 00 00           mov    $0x0,%eax
 8048784:    c9                       leave  
 8048785:    c3                       ret


#endif

xiaozhiwise
关注
专栏目录
「现代C++设计魅力」虚函数继承-thunk技术初探
阿里云云栖号
01-29 2118
简介：工作中使用LLDB调试器调试这一段C++多继承程序的时候，发现通过lldb print(expression命令的别名) 命令获取的指针地址和实际理解的C++的内存模型的地址不一样。那么到底是什么原因呢？ 作者 | 扬阜 来源 | 阿里技术公众号 一 问题背景 1 实践验证 工作中使用LLDB调试器调试这一段C++多继承程序的时候，发现通过lldb print(expression命令的别名) 命令获取的指针地址和实际理解的C++的内存模型的地址不一样。那么到底是什么原因呢？程序如下：
【C++】-- 多态
qq_53413129的博客
04-25 639
总结一下派生类的虚表生成： a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。但是不会在调试窗口显示出来，这也算编译器给优化的一部分。可以通过内存窗口查看。 6. 这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：虚函数存在虚表，虚表存在对象中。注意上
深入C++虚表(虚函数 虚表 反汇编)
05-28
多态是C++语言中最重要的特性之一，而虚表以及虚函数是实现多态的重要手段。许多C++语言的教材对于虚函数的使用以及调用机制有着详细的阐述，但是对于虚表的一些细节内容阐述却并不是很深，对于虚表我们可能会有很多疑问。本文就试图通过使用汇编语言对于虚表实现的细节进行分析，从而加深对多态机制的理解。
反汇编 之 virtual-04 验证虚表
xiaozhi
03-12 306
#include <iostream> #include <stdio.h> class Base { public: int x; int y; virtual void function_1() { printf("function_1...\n"); } virtual void function_2() { ...
C++ virtual函数重写，在继承的时候没有在函数前写virtual关键字也依然是虚函数吗？...
weixin_34092370的博客
07-22 765
  　　比如： 1 class Base 2 { 3 Base() {}; 4 ~Base() {}; 5 virtual void Init(); 6 }; 7 8 class Derived:public Base 9 { 10 virtual void Init();//virtual是必须的吗？ 11 }; ...
子类是否需要重写父类的虚函数
qianqian7759的博客
12-18 7645
子类继承父类时， 父类的纯虚函数必须重写，否则子类也是一个虚类补课实例化。 父类中虚函数（非纯虚函数，即父类对其有定义），则子类也可以不重写，仍然可以实例化。
c++11 新特性 final修饰虚函数时不能被重写
最新发布
xie__jin__cheng的博客
04-19 163
c++11 新特性 final修饰虚函数时不能被重写
浅谈C++ 虚函数分析
12-20
在反汇编代码中，可以看到`Base`构造函数的部分，它将虚表的地址存储在对象实例的内存中，并且在`Der`的构造函数中，没有额外的操作，因为`Base`的虚函数没有实现，直接调用会导致程序异常。`Der::fuck`函数的实现则...
C++虚函数
清浅
04-16 443
1 多态的实现需要使用引用或者指针 1.1 指针和引用是实现多态的必要条件 EG： #include <iostream> using namespace std; class Base { public: virtual void func() { cout << "Base" << endl; } }; class Son:public...
C++ 虚表测试程序
weixin_39234635的博客
03-31 1007
测试C++虚表 #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 <&l
hook虚表监控虚表
零点起步
04-15 890
RTTI(Runtime Type Identification,运行时类型识别）由c++编译器将对象的类型信息嵌入程序的只读数据段，以 支持C++的各种操作符在运行时确定（typeid)和检查(dynamic_cast)一个对象的数据类型。 对微软的编译器而言，RTTI和虚表位置在-4的地址构建。 #include #include #define VTSIZE 6 #pragma pa
C++虚函数表（含测试代码）
cold_windx的博客
10-12 368
自己搞不懂C++虚函数之间的调用关系，特地花费一个下午加一个晚上查资料学习，现在把学到的发上来，供大家学习批评； 在此之前感谢这些大佬的博客等，为我解惑甚多： https://www.cnblogs.com/hushpa/p/5707475.html https://blog.csdn.net/blight_888/article/details/69055766 https://www....
C++反汇编第三讲,反汇编中识别虚表指针,以及指向的虚函数地址
weixin_30379911的博客
12-08 141
　　　　　　C++反汇编第三讲,反汇编中识别虚表指针,以及指向的虚函数地址 讲解之前,了解下什么是虚函数,什么是虚表指针,了解下语法,(也算复习了) 开发知识为了不码字了,找了一篇介绍比较好的,这里我扣过来了,当然也可以看原博客链接:　　http://blog.csdn.net/hackbuteer1/article/details/7558868 一丶虚函数讲解(复习开发,熟悉内存模...
虚函数 多层继承无重写(overwrite) - 常用
weixin_30379531的博客
04-24 152
#include <stdio.h>struct Base1{ virtual void func1() { printf("Base1 func1()\n"); } virtual void func2() { printf("Base1 func2()\n"); }};struct Base2:Base1{ vi...
C++——多态总结
JenaeLi的博客
03-08 528
在博客多态&虚函数中主要对多态的一些基本概念和虚函数做了介绍，下面，我们来探究一下【虚表】。含有虚函数的类 先来看看含有虚函数的类的大小吧！class B { public: virtual void Show() { cout << _b << endl; } public: int _b; }; 一眼看过去，这个类中只有一个int类型的变量_b，
反汇编分析之：虚函数,虚表,多态
张飞online博客
09-10 433
站坑
反汇编研究C++虚函数表,调用类内函数,调用虚函数
a2234503831b的博客
01-09 374
反汇编研究C++虚函数表,调用类内函数,调用虚函数 环境:gcc version 7.4.0 (Ubuntu 7.4.0-1ubuntu1~18.04.1) 测试代码1: #include <iostream> #include <stdio.h> using namespace std; class A { public: virtual void func1() ...
虚表剖析
boboboke
06-11 536
首先介绍一下虚表：在C++语言中，每个有虚函数的类或者虚继承的子类，编译器都会为它生成一个虚拟函数表（简称：虚表），表中的每一个元素都指向一个虚函数的地址。（注意：虚表是从属于类的）一.虚表的存在形式class Base { public: virtual void fun1() { cout << "Base::fun1()" << endl; }
抽象类中可以对虚函数进行实现,但子类必须要重写该函数
Stephen___Qin的博客
11-15 380
抽象类中可以对虚函数进行实现,但子类必须要重写该函数,否则子类仍然是一个抽象类，不能实例化。子类中调用基类的方法可以用基类名::方法.#include <iostream> using namespace std; class A { public: virtual void display()=0 { cout << "A" <...
C语言函数解析：反汇编揭示底层机制
本文主要探讨了如何利用反汇编手段深入解析C语言函数，特别是在程序执行过程中涉及到的关键细节。C语言函数作为编程的基本单元，其调用机制对于理解程序结构和性能至关重要。反汇编技术是一种低级语言到高级语言的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值