多态（2）—— 多态的实现原理

1、虚函数表和vptr指针

• 当类中声明虚函数时，编译器会在类中生成一个虚函数表；
• 虚函数表是一个存储类成员函数指针的数据结构；
• 虚函数表是由编译器自动生成与维护的；
• virtual成员函数会被编译器放入虚函数表中；
• 存在虚函数时，每个对象中都有一个指向虚函数表的指针（vptr指针）。

编译器确定func是否为虚函数：
（1）func不是虚函数，编译器可直接确定被调用的成员函数（静态联编，根据Parent类型来确定）；
（2）func是虚函数，编译器根据对象p的vptr指针，所指的虚函数表中查找func（）函数，并调用。
注意：查找和调用在运行时完成（实现所谓的动态联编）。

 

说明：

（1）通过虚函数表指针vptr调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。

（2）出于效率考虑，没有必要将所有成员函数都声明为虚函数。

（3）C++编译器，在执行run函数，不需要区分是子类对象还是父类对象，而是直接通过p的vptr指针所指向的对象函数执行即可。

 2、证明vptr指针的存在

#include <iostream>
using namespace std;

class Parent
{
public:
    virtual void func()
    {
        cout << "Parent::func(int)..." << endl;
    }

    virtual void func(int a)
    {
        cout << "Parent::func(int)..." << endl;
    }

private:
    int a;
};

class Parent2
{
public:
    void func()
    {
        cout << "Parent2::func(int)..." << endl;
    }

private:
    int a;
};

int main(void)
{
    Parent p1;
    Parent2 p2;

    cout << sizeof(p1) << endl;//8，多出来的4个字节就是vptr指针所占用的空间。
    cout << sizeof(p2) << endl;//4

    return 0;
}

3、vptr指针的分布初始化

对象在创建时，由编译器对vptr指针进行初始化，只有当对象的构造完全结束后，vptr的指向才最终确定——父类对象的vptr指向父类虚函数表，子类对象的vptr指向子类虚函数表。

#include <iostream>
using namespace std;

class Parent
{
public:
    Parent(int a)
    {
        cout << "Parent(int)..." << endl;
        this->a = a;
        print();//此时调用的父类的print()，并不是子类的print()
    }

    virtual void print()
    {
        cout << "Parent::print()..." << a << endl;
    }

private:
    int a;
};

class Child:public Parent
{
public:
    Child(int a,int b):Parent(a)//在调用父类的构造器时，会将vptr指针当做父类的来处理，
                                //此时会临时指向父类的虚函数表
    {
        //将子类对象的空间又变成子类对象处理，vptr指针就从指向父类的表 变成 指向子类的表
        cout << "Child(int,int)..." << endl;
        this->b = b;
        print();//此时vptr指针已经回到了子类的表，调用的是子类的print函数
    }
    virtual void print()
    {
        cout << "Child::print()..." << b << endl;
    }

private:
    int b;
};

int main(void)
{
    Parent *p = new Child(10, 20);
    //vptr指针是分布初始化的
    return 0;
}