多态&多态对象模型

一：什么是c++中的多态

---

引言

多态（Polymorphism）、封装（Encapsulation）和继承（Inheritance）是面向对象思想的“三大特征”，此处俗称“面向对象的三板斧”，而多态是三板斧中最厉害的杀招，是面向对象最精微的内功。

---

定义
所谓多态，其实就是多种形态。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
简单地概括为“一个接口，多种方法”。

---

类别
（1）编译时的多态性。
  编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。

（2）运行时的多态性。
  运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C++中，运行时的多态性通过虚成员实现。

作用
多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

构成多态时，和类型无关，和调用的对象有关。

int main()
{
    Base b;
    Derive d;
    Base* p = &b;
    p->fun1();
    p = &d;
    p->fun1();
    return 0;
}

在讲解多态的单/多 继承模型前，先介绍一下虚函数表

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

二：多态的单继承模型

#include<iostream>
#include<assert.h>
namespace std;

typedef void(*Fun) ();   //定义一个函数指针类型
                         //Fun就是函数指针类型
class Base
{
public:
    virtual void fun1()
    {
        cout << "Base::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Base::fun2()" << endl;
    }
private:
    int d;
};

class Derive : public Base
{
public:
    virtual void fun1()
    {
        cout << "Derive::fun1()" << endl;
    }
    virtual void fun3()
    {
        cout << "Derive::fun3()" << endl;
    }
    virtual void fun4()
    {
        cout << "Derive::fun4()" << endl;
    }
private:
    int d;
};

//
void Print_Table(int* VTable)
{
    cout << "虚表地址" << endl;
    for (int i = 0; VTable[i] != 0; i++)
    {
        printf("第%d个虚函数地址是ox%p->", i, VTable[i]);
        Fun f = (Fun)VTable[i];
        f();
    }
}
int main()
{
    Base b;
    Derive d;
    int* VTableB = *((int**)(&b));
    int* VTableD = *((int**)(&d));
    Print_Table(VTableB);
    Print_Table(VTableD);
    return 0;
}

上面这个图是父类Base的虚表

三：多态的多继承模型

#include<iostream>

using namespace std;

typedef void(*Fun) ();   //定义一个函数指针类型

void Print_Table(int* VTable)
{
    cout << "虚表地址" << endl;
    for (int i = 0; VTable[i] != 0; i++)
    {
        printf("第%d个虚函数地址是ox%p->", i, VTable[i]);
        Fun f = (Fun)VTable[i];
        f();
    }
}

class Base1
{
public:
    virtual void fun1()
    {
        cout << "Base1::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Base1::fun2()" << endl;
    }
private:
    int b1;
};
class Base2
{
public:
    virtual void fun1()
    {
        cout << "Base2::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Base2::fun2()" << endl;
    }
private:
    int b2;
};


class Derive : public Base1,public Base2
{
public:
    virtual void fun1()
    {
        cout << "Derive::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Derive::fun2()" << endl;
    }
    virtual void fun3()
    {
        cout << "Derive::fun3()" << endl;
    }
private:
    int d;
};

int main()
{
    Derive d;
    int* Vtable = *((int**)(&d));
    //打印第一个虚表，也就是第一个继承的Base1
    Print_Table(Vtable);
    //Base2的虚函数表在Base1的后边，因此要给地址+一个Base1的大小
    Vtable = (int*)(*((int*)&d + sizeof(Base1) / 4 ));
    Print_Table(Vtable);//打印第二个虚表
    return 0;
}

多重继承中，子类会同时重写多个父类中相同的函数，并且子类将自己的虚函数存放在第一个继承的虚函数表中。子类没有自己的虚表，继承第一个父类的虚表

---