有关多态的那点事丶

前奏—虚函数表

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

1.什么是多态 ?
所谓多态性就是不同对象收到相同的消息时，产生不同的动作。直观来说，多态性是指用一个名字定义不同的函数，这些函数执行不同但又类似的操作，从而可以使用相同的方式来调用这些具有不同功能的同名函数。简单的说:就是用基类的引用指向子类的对象。

多态的分类：
编译时的多态性。编译时的多态性是通过重载来实现的。
运行时的多态性。动态多态就是通过继承重写基类的虚函数实现的多态，因为是在运行时决议确定，所以称为动态多态。
实现多态的方法：虚函数，抽象类，覆盖，模板。
构成多态的条件：
1.要有继承 。
2.要有虚函数的重写。
3.父类的指针/引用调用虚函数。
构成多态时，和类型无关，和调用的对象有关。
使用多态的好处：
多态性机制不仅增加了面向对象软件系统的灵活性，进一步减少了冗余信息，而且显著提高了软件的可重用性和可扩充星星。多态的应用可以使编程显得更简便.更便利。

多态的应用：

#include<iostream>
using namespace std;
class A
{
public:
    virtual void fun1()
    {
        cout << "A::fun1() "<< endl;
    }
};
class B :public A
{
public:
    virtual void fun1()
    {
        cout << "B::fun1()" << endl;
    }
};


int main()
{
    A a;
    B b;
    A* p = &a;
    p->fun1();
    p = &b;
    p->fun1();
    system("pause");
    return 0;
}

上述实例中父类A的指针指向父类对象时，则调用父类的函数fun1（）,当指针指向子类时，则调用子类fun1（）.

---

单继承对象模型

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)//虚表内虚函数地址以0作为结束标志 
    {
        printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
        FUNC f = (FUNC)VTable[i];
        f();
    }

    cout << endl;
}

int main()
{
    Base b1;
    Derive d1;
    int* VTable1 = (int*)(*(int*)&b1);//拿到b1的首地址，把它强转成int*，让他读取到前4个字节的内容（也就是指向虚表的地址），再然后对那个地址解引用，我们已经拿到虚表的首地址了，但是此时这个变量的类型解引用后是int，不能够传入函数，所以我们再对他进行一个int*的强制类型转换，这样我们就传入参数了，开始函数执行了，我们一切都是在可控的情况下使用强转，使用强转你必须要特别清楚的知道内存的分布结构。
    int* VTable2 = (int*)(*(int*)&d1);
    PrintVTable(VTable1);
    PrintVTable(VTable2);
    system("pause");
    return 0;
}

首先子类的func1()重写了父类的func1()，虚表里存的是子类的func1(),接下来父类的func2(),子类的func3(),func4()都是虚函数，所以虚表里会有4个元素，分别为子类的fun1(),父类fun2(),子类fun3()，子类fun4()。

---

多继承对象模型

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;
}

int main()
{
    Derive d1;
    int* VTable = (int*)(*(int*)&d1);
    PrintVTable(VTable);
    VTable = (int *)(*((int*)&d1 + sizeof (Base1) / 4));
    PrintVTable(VTable);
    system("pause");
    return 0; 
}

监视显示有Base1和Base2两个虚表，但是在监视中我们并没有发现子类的func3函数！！！！

---

---

调试结果显示func3()没有自己开辟虚函数表，也没有存在Base2的虚函数表中，而是存在了Base1的虚函数表中，由此我们得出当涉及多继承时，子类的虚函数会存在先继承的那个类的虚函数表里。

对象模型–菱形虚拟继承

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Base1
{
public:
    virtual void fun1()
    {
        cout << "Base1::fun1" << endl;
    }
public:
    int _a;
};
class Base2 :virtual public Base1
{
public:
    virtual void fun1()
    {
        cout << "Base2::fun1" << endl;
    }
    virtual void fun2()
    {
        cout << "Base2::fun2 " << endl;
    }
public:
    int _b;
};
class Base3 :virtual public Base1
{
public:
    virtual void fun1()
    {
        cout << "Base3::fun1" << endl;
    }
    virtual void fun2()
    {
        cout << "Base3::fun2" << endl;
    }
public:
    int _c;
};
class Base4 : public Base2, public Base3
{
public:
    virtual void fun1()
    {
        cout << "Base4::fun1" << endl;
    }
    virtual void fun2()
    {
        cout << "Base4::fun2" << endl;
    }
public:
    int _d;
};
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;
}

int main()
{
    Base4 a;
    a.Base2::_a = 1;
    a.Base3::_a = 2;
    a._b = 3;
    a._c = 4;
    a._d = 5;
    PrintVTable(*((int**)&a));
    PrintVTable(*((int**)((char*)&a + sizeof(Base2)-sizeof(Base1))));
    PrintVTable(*((int**)((char*)&a + sizeof(Base2)+sizeof(Base3)-2 * sizeof(Base1)+4)));
    system("pause");
    return 0;
}

Base2 Base3 中重写了Base1中的fun1() Base4继承了 Base2 and Base3 重写了fun1() fun2()


调试结果

---

---