多态及其对象模型

1.多态
(1)定义：多态就是多种形态即指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。
(2)条件
1)有虚函数重写。
*虚函数：类的成员函数前面加virtual关键字，则构成虚函数。
*虚函数重写：当子类定义了一个与父类完全相同的虚函数时，就称这个函数重写（覆盖）了父类的虚函数。

class Person
{
public:
   virtual viod BuyTickets()//父类虚函数
   {
      cout<<"买票"<<endl;
   }
};

class Student ：public Person
{
public:
   virtual void BuyTickets()//子类虚函数重写/覆盖父类虚函数
   {
      cout<<"买票-半价"<<endl;
   }
};

*纯虚函数：在成员函数形参后面写=0，即为纯虚函数，包含纯虚函数的类是抽象类（接口类），抽象类不能实例化出对象，纯虚函数在派生类中重新定义后才能实例化出对象。// virtual void BuyTickets () =0;纯虚函数
2)父类的指针/引用调用虚函数。即当指向父类调用的就是父类的虚函 数，当指向子类调用的就是子类的虚函数。
(3)分类：
1)静态多态：就是重载，即编译时多态，在编译时确定对象使用的形式。
2)动态多态:即运行时多态，其具体引用的对象在运行时才能确定。

*虚函数表（Vtable）：通过一块连续的内存来储存虚函数的地址。此表解决了继承，虚函数（重写 ）的问题，在有虚函数对象实例中都存在虚表，指明了实际应该调用的虚函数。

2.单继承对象模型&多继承对象模型
（1）单继承对象模型

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

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;
};
typedef void(*FUNC)();
void PrintVTable(int*VTable)
{
    cout << "虚表地址" << VTable << endl;
    for (int i = 0; VTable[i] != 0; ++i)
    {
        printf("第%d个虚函数地址:0X%x,->", i, VTable[i]);
        FUNC f = (FUNC)VTable[i];
        f();
    }
    cout << endl;
}
void Test1()
{
    Base b1;
    Derive d1;

    int*VTable1 = (int*)(*(int*)&b1);
    int*VTable2 = (int*)(*(int*)&d1);

    PrintVTable(VTable1);
    PrintVTable(VTable2);
}
int main()
{
    Test1();
    getchar();
    return 0;
}

（2）多继承对象模型

#include<iostream>
using namespace std;
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;
};
typedef void(*FUNC)();
void PrintVTable(int*VTable)
{
    cout << "虚表地址" << VTable << endl;
    for (int i = 0; VTable[i] != 0; ++i)
    {
        printf("第%d个虚函数地址:0X%x,->", i, VTable[i]);
        FUNC f = (FUNC)VTable[i];
        f();
    }
    cout << endl;
}
void Test2()
{
    Derive d1;
    int*VTable = (int*)(*(int*)&d1);
    PrintVTable(VTable);
    //Base2虚函数表在对象Base1后面
    VTable = (int*)(*((int*)&d1 + sizeof(Base1) / 4));
    PrintVTable(VTable);
}
int main()
{
    Test2();
    getchar();
    return 0;
}