C++对象模型（9）-- 虚函数1

虚函数是指用 virtual 关键字修饰的类成员函数。其定义如下所示：

virtual void vir_print(){}

虚函数的作用是允许使用基类的指针来调用子类的函数，从而实现“多态”。含虚函数的类在编译时会产生一张虚函数表vtbl，里面保存了函数的调用地址。类对象通过虚函数表指针vptr找到虚函数表vtbl，通过vtbl找到对应函数的调用地址，然后调用执行。

1、虚函数表指针位置

一般地，虚函数表指针位于对象的开头位置。

我们可以写一段代码来测试一下：

class Base {
public:
    int t_i = 8;
    virtual void vir_print() {
        std::cout << "Base::vir_print()" << std::endl;
    }
};

int main()
{
    Base base;
    return 0;
}

我们用VS2019来调试上面的程序，把断点设在第12行的return 0处，运行后打开“快速监视”工具，在“表达式”窗口输入：&base。可以看到base对象的内存布局如下：

另外，我们也可以通过读取二进制的方式来验证base对象的内存模型。我们在main()函数中加入下面的代码：

std::cout << "sizeof(base) = " << sizeof(base) << std::endl;
int* pt_i = (int*)((char*)&base + 4);
std::cout << "t_i = " << *pt_i << std::endl;

程序的输出结果为：

sizeof(base) = 8

t_i = 8

所以对象的大小是8个字节，第5 - 8个字节是变量t_i，所以1-4个字节是虚函数表指针的。

2、虚函数的手工调用

为了加深对虚函数调用过程的认识，我们直接通过虚函数表指针来调用虚函数。

Base类的定义如下：

class Base {
public:
    int t_i = 8;
    virtual void vir_f() {
        std::cout << "Base::vir_f()" << std::endl;
    }

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

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

Base类对象的内存布局是下面这样的。

虚函数表和成员函数都是属于Base类的，虚函数表指针是属于base对象的，每个对象都会生成自己的虚函数表指针，但指针指向的虚函数表地址都相同。

main()函数的定义如下：

int main()
{
    Base base;
    long* pvptr = (long*)&base; //因为对象的首地址是虚函数表指针
    long* vptr = (long*)(*pvptr); //指针的值就是指向的虚函数表

    //定义函数指针,指向 void (void)函数
    typedef void (*Func)(void);

    //因为虚函数表是个数组,所以我们可以通过vptr[i]的方式来调用对应的虚函数
    Func vir_f = (Func)vptr[0];
    Func vir_g = (Func)vptr[1];
    Func vir_h = (Func)vptr[2];

    vir_f();
    vir_g();
    vir_h();
}

3、继承虚函数表分析

3.1 单继承

假设有Base, Derive两个类，其中Derive继承自Base类。代码如下所示：

class Base {
public:
    int b_i = 8;
    virtual void vir_f() {
        std::cout << "Base::vir_f()" << std::endl;
    }

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

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

    int d_i = 9;
};

class Derive :public Base {
public:
    int d_i = 9;
    void vir_f() {
        std::cout << "Derive::vir_f()" << std::endl;
    }

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

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

int main()
{
    Derive derive;

    return 0;
}

通过VS2019的“快速监视”窗口，我们可以看到derive对象的内存布局是这样的：

从图中我们可以看到derive对象的内存布局顺序从上到下是这样排列的：

虚函数表指针vptr、Base类的int变量b_i、Derive类的int变量d_i。

关于虚函数，有这么几个要点：

（1）只要在父类中是虚函数，子类中不用写virtual也依然是虚函数。

（2）如果父类中有虚函数，就算子类没有虚函数，子类也会创建自己的虚函数表。

（3）子类中的虚函数会覆盖父类中的同名虚函数。

（4）在把子类对象赋值给父类时，会用子类对象的值去初始化父类对象，但父类对象的虚函数表指针指向的依然是它自己的虚函数表。

关于第4点，我们可以通过下面的代码来验证：

Derive derive;
Base base = derive;
long* pvptr = (long*)&base; //因为对象的首地址是虚函数表指针
long* vptr = (long*)(*pvptr); //指针的值就是指向的虚函数表

//定义函数指针,指向 void (void)函数
typedef void (*Func)(void);

//因为虚函数表是个数组,所以我们可以通过vptr[i]的方式来调用对应的虚函数
Func vir_f = (Func)vptr[0];
Func vir_g = (Func)vptr[1];
Func vir_h = (Func)vptr[2];

vir_f();
vir_g();
vir_h();

输出结果如下：

Base::vir_f()

Base::vir_g()

Base::vir_h()

3.2 虚函数的动态绑定

前面说过：在把子类对象赋值给父类时，会用子类对象的值去初始化父类对象，但父类对象的虚函数表指针指向的依然是它自己的虚函数表。

Derive derive;
Base base = derive;
base.vir_f(); //输出Base::vir_f()

这里读者是否有疑问，这个base是用derive对象赋值的，应该调用Derive类的 vir_f()方法才对啊？

这里，必须说一下“静态绑定”、“动态绑定”这2个概念。

（1）静态绑定：绑定的是静态类型，所对应的函数或者属性依赖对象的静态类型，发生在编译期。

（2）动态绑定：绑定的是动态类型，所对应的函数或者属性依赖对象的动态类型，发生在运行期。

虚函数是动态绑定的，Base base = derive;只是把derive对象是值赋给了base对象，base对象已经确定了，没有动态绑定的动作，所以base.vir_f()只能调用自己的函数。要调用子类的虚函数，必须用类指针去动态调用。

Derive derive;
Base* pb = &derive; //输出Derive::vir_f()
pb->vir_f();

Base& b = derive; //输出Derive::vir_f()
b.vir_f();

3.3 多重继承

我们在前面例子的基础上，加入一个新类Base2：

class Base2 {
public:
    int b2_i = 10;
    virtual void vir_f2() {
        std::cout << "Base2::vir_f2()" << std::endl;
    }

    virtual void vir_g2() {
        std::cout << "Base2::vir_g2()" << std::endl;
    }

    virtual void vir_h2() {
        std::cout << "Base2::vir_h2()" << std::endl;
    }
};

然后让Derive类继承这个Base2类：

class Derive :public Base, public Base2 {......}

derive对象的内存布局如下：

对于多重继承下的虚函数，有几个要点：

（1）一个类如果继承自多个父类，且父类都有虚函数，则子类就会有多个虚函数表。

（2）类有几个虚函数表，其对象就会有对应的几个虚函数表指针。

（3）子类对象与第一个基类共用1个虚函数表指针。