【C++】多态 -- 详解（下）

class Person {
public:
    virtual void BuyTicket()
    {
        cout << "买票-全价" << endl;
    }
};
 
class Student : public Person {
public:
    virtual void BuyTicket()
    {
        cout << "买票-半价" << endl;
    }
};
 
void Func(Person& p)
{
    p.BuyTicket();
}
 
int main()
{
    Person Mike;
    Func(Mike);
 
    Student Johnson;
    Func(Johnson);
 
    return 0;
}

class Person {
public:
  virtual void BuyTicket()
    {
        cout << "买票-全价" << endl;
    }
};
 
void Func(Person* p)
{
    //...
    p->BuyTicket();
 
// p中存的是Mike对象的指针，将p移动到eax中
001940DE  mov         eax,dword ptr [p]
// [eax]就是取eax值指向的内容，这里相当于把Mike对象头4个字节(虚表指针)移动到了edx
001940E1  mov         edx,dword ptr [eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE  mov         eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的中取找的。
001940EA  call        eax  
001940EC  cmp         esi,esp  
}
 
int main()
{
    Person Mike;
    Func(&Mike);
 
    return 0;
}

int main()
{
    //...
// 首先BuyTicket虽然是虚函数，但是Mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call地址
    Person Mike;
    Mike.BuyTicket();
 
00195182  lea         ecx,[mike]
00195185  call        Person::BuyTicket (01914F6h) 
 
    //... 
}

class Base { 
public :
    virtual void func1()
    {
        cout << "Base::func1" << endl;
    }
    virtual void func2()
    {
        cout << "Base::func2" << endl;
    }
private :
    int a;
};
 
class Derive :public Base { 
public :
    virtual void func1()
    {
        cout << "Derive::func1" << endl;
    }
    virtual void func3()
    {
        cout << "Derive::func3" << endl;
    }
    virtual void func4()
    {
        cout << "Derive::func4" << endl;
    }
private :
    int b;
};

// 函数指针VFPTR
typedef void(*VFPTR) ();
 
// 打印虚表，传入虚函数指针数组
void PrintVTable(VFPTR vTable[])
{
    // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        // 依次打印虚表各元素
        printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        // 把虚表各元素由void*强转为函数指针类型后，赋值给函数指针f
        VFPTR f = vTable[i];
        // 调用函数
        f();
    }
    cout << endl;
}
 
int main()
{
    Base b;
    Derive d;
 
    // 思路：取出b、d对象的头4字节，就是虚表的指针，前面我们说到虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
    // 1、先取b的地址，强转成一个int*的指针
    // 2、再解引用取值，就取到了b对象头4字节的值，这个值就是指向虚表的指针
    // 3、再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    // 4、虚表指针传递给PrintVTable进行打印虚表
    // 5、需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。
 
    VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    PrintVTable(vTableb); // 打印对象b的虚表
 
    VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    PrintVTable(vTabled); // 打印对象d的虚表
 
    return 0;
}

class Base1 {
public:
    virtual void func1()
    {
        cout << "Base1::func1" << endl;
    }
    virtual void func2()
    {
        cout << "Base1::func2" << endl;
    }
private:
    int b1;
};
 
class Base2 {
public:
    virtual void func1()
    {
        cout << "Base2::func1" << endl;
    }
    virtual void func2()
    {
        cout << "Base2::func2" << endl;
    }
private:
    int b2;
};
 
class Derive : public Base1, public Base2 {
public:
    virtual void func1()
    {
        cout << "Derive::func1" << endl;
    }
    virtual void func3()
    {
        cout << "Derive::func3" << endl;
    }
private:
    int d1;
};
 
// 函数指针VFPTR
typedef void(*VFPTR) ();
 
// 打印虚表，传入虚函数指针数组的地址（即虚表指针）
void PrintVTable(VFPTR vTable[])
{
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        // 依次打印虚表各元素
        printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        // 把虚表各元素赋值给函数指针f
        VFPTR f = vTable[i];
        // 调用函数
        f();
    }
    cout << endl;
}
 
int main()
{
    Derive d;
 
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    PrintVTable(vTableb1); // 打印第一张虚表
 
    // 必须先强转成char*，然后加Base1大小个字节，再强转成int*，解引用，强转成VFPTR*
    VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
    PrintVTable(vTableb2); // 打印第二张虚表
 
    return 0;
}