C++中的多态

在学习C++的时候，我们知道C++有三个重要的特性：封装，继承，多态。
那么，我们来看一下C++是怎么实现多态，以及多态实现的对象模型。

所谓多态，其实就是“多种形态”。
C++中虚函数的主要作用就是实现多态。简单说父类的指针/引用调用重写的虚函数，当父类指针/引用指向父类对象时调用的是父类的虚函数，指向子类对象时调用的是子类的虚函数。

1.父类的指针或者引用调用重写的虚函数。

class Base
{
public:
    virtual void f1()
    {
        std::cout << "Base::f1()" << std::endl;
    }

    void f2()
    {
        std::cout << "Base::f2()" << std::endl;
    }
};

class Devir:public Base
{
public:
    virtual void f1()
    {
        std::cout << "Devir::f1()" << std::endl;
    }

    virtual void f2()
    {
        std::cout << "Devir::f2()" << std::endl;
    }
};

在Base类中，f1()为虚函数，Devir类共有继承Base类，Devir类中的f1()进行了重写，而f2()不满足重写。这时我们拿父类的指针/引用指向Devir的对象。

int main()
{
    Base b;
    Devir d;

    Base* ptr = &b;
    ptr->f1();
    ptr->f2();

    ptr = &d;
    ptr->f1();
    ptr->f2();

    Base& d1 = d;
    d1.f1();
    d1.f2();

    return 0;
}

最终的结果如下

2.内存布局，通过对虚表地址的访问，找到虚函数的地址。

每一个虚函数表都存放着指向虚函数的指针，我们通过访问虚函数表的指针，找到虚函数所在的空间，对空间中的虚函数一一访问。

class Base
{
public:
    virtual void f1()
    {
        std::cout << "Base::f1" << std::endl;
    }

    void f2()
    {
        std::cout << "Base::f2" << std::endl;
    }

    virtual void f3()
    {
        std::cout << "Base::f3" << std::endl;
    }

private:
    int a;
};

class Devri :public Base
{
    virtual void f3()
    {
        std::cout << "Devir::f3" << std::endl;
    }

private:
    int z;
};

typedef void(*VirFunc)();

void PrintVirtualTable(int* VirTable)
{
    std::cout << "VirtualTable:" << VirTable << std::endl;
    for (int i = 0; VirTable[i] != 0; ++i)
    {
        VirFunc f = (VirFunc)VirTable[i];
        f();
    }
}
int main()
{
    Base b;
    Devri d;

    PrintVirtualTable((int*)(*((int*)&b)));
    PrintVirtualTable((int*)(*((int*)&d)));

    return 0;
}

3.静态的多态和动态的多态。

多态就是多种形态，C++的多态分为静态多态和动态多态。
1. 静态多态就是重载，因为是在编译期决议确定，所以称为静态多态。
2. 动态多态就是通过继承重写基类的虚函数实现的多态，因为是在运行时决议确定，所以称为动态多态。

动态的多态实现需要条件：
1>存在继承。
2>父类的引用或指针指向子类的对象。
3>存在重写。

class A
{
public:
    virtual void f1()
    {
        std::cout << "Af1()" << std::endl;
    }

    virtual void f2()
    {
        std::cout << "Af2()" << std::endl;
    }

    void print()
    {
        std::cout << "print()" << std::endl;
    }

    void print(int i)
    {
        std::cout << "print(int " << i << ")" << std::endl;
    }

private:
    int a;
};

class B :public A
{
public:
    virtual void f2()
    {
        std::cout << "Bf2()" << std::endl;
    }
};

void Test(A& aa)
{
    aa.f2();
    aa.print();
    aa.print(10);
}
int main()
{
    A a;
    B b;
    Test(a);
    Test(b);
    return 0;
}

通过对f2()、print()、print(int i)的调用，我们通过反汇编的方式得到调用过程。

我们发现，在实现动态的多态时，运行时到虚函数表寻找调用函数的地址，而静态多态编译时确定了函数的地址。