虚表和虚表指针2.0

　　继续从汇编内存层次上对虚表和虚表指针进行分析

　　（任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法）

0x01 对象调用自身虚函数

class CVirtual
{
public:
    virtual int GetNumber()
    {
        return m_nNumber;
        return 0;
    }
    virtual void SetNumber(int nNumber)
    {
        m_nNumber = nNumber;
    }
private:
    int m_nNumber;
};
 
int main()
{
    //int a = sizeof(CVirtual);
    CVirtual TheVirtual;
 
    TheVirtual.SetNumber(20);
    printf("%d\n", TheVirtual.GetNumber());
    return 0;
}

　　反汇编：

    21: int main()
    22: {
00EC3DA0 55                   push        ebp  
00EC3DA1 8B EC                mov         ebp,esp  
00EC3DA3 81 EC D0 00 00 00    sub         esp,0D0h  
00EC3DA9 53                   push        ebx  
00EC3DAA 56                   push        esi  
00EC3DAB 57                   push        edi  
00EC3DAC 8D BD 30 FF FF FF    lea         edi,[ebp-0D0h]  
00EC3DB2 B9 34 00 00 00       mov         ecx,34h  
00EC3DB7 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00EC3DBC F3 AB                rep stos    dword ptr es:[edi]  
    23:     //int a = sizeof(CVirtual);
    24:     CVirtual TheVirtual;
00EC3DBE 8D 4D F4             lea         ecx,[TheVirtual]  
00EC3DC1 E8 6E D5 FF FF       call        CVirtual::CVirtual (0EC1334h)  
    25: 
    26:     TheVirtual.SetNumber(20);
00EC3DC6 6A 14                push        14h  
00EC3DC8 8D 4D F4             lea         ecx,[TheVirtual]  
00EC3DCB E8 0B D4 FF FF       call        CVirtual::SetNumber (0EC11DBh)  
    27:     printf("%d\n", TheVirtual.GetNumber());
00EC3DD0 8D 4D F4             lea         ecx,[TheVirtual]  
00EC3DD3 E8 BC D4 FF FF       call        CVirtual::GetNumber (0EC1294h)  
00EC3DD8 50                   push        eax  
00EC3DD9 68 3C 6B EC 00       push        offset string "%d\n" (0EC6B3Ch)  
00EC3DDE E8 97 D5 FF FF       call        _printf (0EC137Ah)  
00EC3DE3 83 C4 08             add         esp,8  
    28:     return 0;
00EC3DE6 33 C0                xor         eax,eax  
    29: }

　　虚函数SetNumber()反汇编分析：、

    13:     virtual void SetNumber(int nNumber)
    14:     {
00EC1770 55                   push        ebp  
00EC1771 8B EC                mov         ebp,esp  
00EC1773 81 EC CC 00 00 00    sub         esp,0CCh  
00EC1779 53                   push        ebx  
00EC177A 56                   push        esi  
00EC177B 57                   push        edi  
00EC177C 51                   push        ecx  
00EC177D 8D BD 34 FF FF FF    lea         edi,[ebp-0CCh]  
00EC1783 B9 33 00 00 00       mov         ecx,33h  
00EC1788 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00EC178D F3 AB                rep stos    dword ptr es:[edi]  
00EC178F 59                   pop         ecx  
00EC1790 89 4D F8             mov         dword ptr [this],ecx  
    15:         m_nNumber = nNumber;
00EC1793 8B 45 F8             mov         eax,dword ptr [this]  
00EC1796 8B 4D 08             mov         ecx,dword ptr [nNumber]  
00EC1799 89 48 04             mov         dword ptr [eax+4],ecx  
    16:     }
00EC179C 5F                   pop         edi  
    16:     }
00EC179D 5E                   pop         esi  
00EC179E 5B                   pop         ebx  
00EC179F 8B E5                mov         esp,ebp  
00EC17A1 5D                   pop         ebp  
00EC17A2 C2 04 00             ret         4  

　　可以看到，虚函数与普通函数的实现流程并无差别，并没有看到虚表指针之类的操作。

　　也就是说，直接通过对象调用自身的成员虚函数的时候，编译器使用了直接调用函数的方式，没有访问续表指针，来间接获取虚函数地址。

0x02 析构函数对虚表指针的操作

class CVirtual
{
public:
    virtual int GetNumber()
    {
        return m_nNumber;
        return 0;
    }
    virtual void SetNumber(int nNumber)
    {
        m_nNumber = nNumber;
    }
    ~CVirtual()
    {
 
    }
private:
    int m_nNumber;
};
 
int main()
{
    //int a = sizeof(CVirtual);
    CVirtual TheVirtual;
 
    //TheVirtual.SetNumber(20);
    //printf("%d\n", TheVirtual.GetNumber());
    return 0;
}

　　反汇编：

   17:  ~CVirtual()
    18:     {
00A51730 55                   push        ebp  
00A51731 8B EC                mov         ebp,esp  
00A51733 81 EC CC 00 00 00    sub         esp,0CCh  
00A51739 53                   push        ebx  
00A5173A 56                   push        esi  
00A5173B 57                   push        edi  
00A5173C 51                   push        ecx  
00A5173D 8D BD 34 FF FF FF    lea         edi,[ebp-0CCh]  
00A51743 B9 33 00 00 00       mov         ecx,33h  
00A51748 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00A5174D F3 AB                rep stos    dword ptr es:[edi]  
00A5174F 59                   pop         ecx  
00A51750 89 4D F8             mov         dword ptr [this],ecx  
00A51753 8B 45 F8             mov         eax,dword ptr [this]  
00A51756 C7 00 34 6B A5 00    mov         dword ptr [eax],offset CVirtual::`vftable' (0A56B34h)  
    19: 
    20:     }

　　从析构函数中摘取关键的汇编指令：

00A5174F 59                   pop         ecx  
00A51750 89 4D F8             mov         dword ptr [this],ecx  
00A51753 8B 45 F8             mov         eax,dword ptr [this]  

　　可以看出这和我写的上一篇博客：虚表与虚表指针中构造函数的操作是一模一样的，pop ecx还原this指针的值到ecx中，然后通过ecx赋值给this指针，再由eax得到this指针。

　　最后一步：

1	00A51756 C7 00 34 6B A5 00 mov dword ptr [eax],offset CVirtual::`vftable' (0A56B34h)

　　将当前类的续表首地址赋值到虚表指针中。

　　通过分析构造函数和析构函数的流程可知：

　　两者对虚标的操作过程几乎一致，都是将虚表指针设置为当前对象所属类的虚表首地址。看起来相同，其实差别很大。

　　构造函数当中的虚表指针初始化，是将虚表指针初始化为正确的虚函数表基地址；而析构函数写入虚表指针，是将原对象的虚表指针重新赋值，其指针可能指向了另外一个虚表。

　　下面有一份继承代码的反汇编来验证析构函数中对象虚表指针的重新赋值（验证结果为：父类指针指向子类的对象，并调用子类中的同名虚函数时，虚表指针会指向子类的虚函数表，再调用子类的函数，对象析构时，父类析构函数会将当前的虚表指针重新赋值为父类的虚表指针。）

　　代码流程：

#include<iostream>  
using namespace std;
 
class A
{
public:
    void 刘大大()
    {
        printf("1\n");
    }
    virtual void 刘小()
    {
        printf("2\n");
    }
    ~A()
    {
 
    }
};
class B : public A
{
public:
    void 刘大大()
    {
        printf("3\n");
    }
    void 刘小()
    {
        printf("4\n");
    }
};
int main(void)
{
    B b;
 
    A *p = &b;
 
    p->刘小();
 
    return 0;
}