聊一聊C++虚函数表的问题

之前只是看过C++虚函数表相关介绍，今天有空就来写代码研究一下。

面向对象的编程语言有3大特性：封装、继承和多态。C++是面向对象的语言（与C语言主要区别），所以C++也拥有多态的特性。

C++中多态分为两种：静态多态和动态多态。

静态多态为编译器在编译期间就可以根据函数名和参数等信息确定调用某个函数。静态多态主要体现为函数重载和运算符重载。

函数重载即类中定义多个同名成员函数，函数参数类型、参数个数和返回值不完全相同，编译器编译后这些同名函数的函数名会不一样，也就是说编译期间就确定了调用某个函数。C语言函数编译后函数名就是原函数名，C++函数名为原函数名拼接函数参数等信息。

动态多态即运行时多态，在程序执行期间(非编译期)判断所引用对象的实际类型，根据其实际类型调用相应的方法。动态多态由虚函数来实现。
比如

class Base{};
class A: public Base{};
class A: public Base{};

Base *base = new A; // base静态类型为Base*，动态类型为A*
base = new B; // base动态类型变为B*了

探索虚函数表结构

之前的文件提到过，一个类占用的空间，如果有虚函数就会占用8字节的空间来存放虚函数表的地址。
虚函数表内存空间 中依次存放着各个虚函数的指针，通过这个指针可以调用相关的虚函数。

下面通过代码来验证一下上面这个内存结构，定义一个Base类，中间有3个方法，f1/f2/f3。

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

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

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

实例化这个类后的内存模型如下图所示：

下面通过代码来验证这个内存模型。

int main() {
    typedef void(*Fun)();  // Fun为f1 f2 f3的函数类型

    std::cout << sizeof(Base)<< std::endl;  // 输出 8

    Base b;
    printf("b ptr = %p\n", &b);  // b ptr = 0x7ffeee41ac30

    long v_table_addr_value = *(long*)&b; // 取&b指针 前8字节的值，即虚函数表地址值
    printf("vtable ptr = 0x%lx\n", v_table_addr_value); // vtable ptr = 0x557dae962d48

    void *v_table_addr = (void*)v_table_addr_value;  // 把这8字节值转为地址，即为虚函数表指针
    printf("vtable ptr = %p\n", v_table_addr); // vtable ptr = 0x557dae761cd4

    long f1_addr_value = *(long*)v_table_addr;  // 虚函数表前8字节为f1()函数指针值
    printf("f1() ptr = 0x%lx\n", f1_addr_value);  // f1() ptr = 0x557dae761cd4
    Fun f1 = (Fun)f1_addr_value;  // 虚函数表内存第1个8字节值转为函数指针
    f1();  // 输出：virtual void Base::f1()

    long f2_addr_value = *(long*)((char*)v_table_addr + 8);  // 虚函数表8-16字节为f2()函数指针值
    printf("f2() ptr = 0x%lx\n", f2_addr_value);  // f2() ptr = 0x557dae761d0c
    Fun f2 = (Fun)f2_addr_value;  // 虚函数表内存第2个8字节值转为函数指针
    f2();  // 输出：virtual void Base::f2()

    long f3_addr_value = *(long*)((char*)v_table_addr + 16);  // 虚函数表前16-24字节为f3()函数指针值
    printf("f3() ptr = 0x%lx\n", f3_addr_value);  // f3() ptr = 0x557dae761d44
    Fun f3 = (Fun)f3_addr_value;  // 虚函数表内存第3个8字节值转为函数指针
    f3();  // virtual void Base::f3()

    return 0;
}

通过上述代码的输出结果可以验证上图的内存模型。

继承基类重写虚函数

现在定义一个继承类Derived，重写了f1()函数，也就是覆盖掉了Base类中的函数f1()。同时又新增了虚拟函数f4()。

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

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

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

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

    virtual void f4() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

通过上一节类似的代码可以验证new Derived()其内存模型为

由此可以得出以下结论：

1. 虚函数按照其声明顺序放于表中。
2. 父类的虚函数在子类的虚函数前面。
3. 覆盖的函数放到了虚函数表中原来父类虚函数的位置。
4. 没有被覆盖的虚函数函数位置不变。

继承N个基类就有N个虚函数表，接下来使用代码去验证。

有3个基类Base1，Base2, Base3，都有两个虚函数f1()、f2()。最后Derived 类继承这3个基类。并重写f1()函数，新增f4()函数。

class Base1 {
public:
    virtual void f1() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

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

class Base2 {
public:
    virtual void f1() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

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

class Base3 {
public:
    virtual void f1() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

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

class Derived : public Base1, public Base2, public Base3 {
public:
    void f1() override {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    virtual void f4() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

此时，sizeof(Derived) 等于24，可以基本确定类实例中有3个虚函数表指针。
下面通过代码来检查一下内存数据。

int main() {
    typedef void(*Fun)();

    std::cout << sizeof(Derived) << std::endl; // 24

    Derived *d = new Derived();
    printf("b ptr = %p\n", d); // b ptr = 0x5624201d9280

    long v_table1_addr_value = *(long *) d;  // 第1个虚函数表地址值
    printf("vtable1 ptr = 0x%lx\n", v_table1_addr_value); // vtable1 ptr = 0x56241e42ac48

    long b1f1_addr_value = *(long *) v_table1_addr_value;
    printf("b1f1() ptr = 0x%lx\n", b1f1_addr_value); // b1f1() ptr = 0x56241e22a170
    Fun b1f1 = (Fun) b1f1_addr_value;
    b1f1(); // virtual void Derived::f1()

    long b1f2_addr_value = *((long *) v_table1_addr_value + 1);
    printf("b1f2() ptr = 0x%lx\n", b1f2_addr_value); // b1f2() ptr = 0x56241e22a058
    Fun b1f2 = (Fun) b1f2_addr_value;
    b1f2(); // virtual void Base1::f2()

    long b1f3_addr_value = *((long *) v_table1_addr_value + 2);
    printf("b1f3() ptr = 0x%lx\n", b1f3_addr_value); // b1f3() ptr = 0x56241e22a1b4
    Fun b1f3 = (Fun) b1f3_addr_value;
    b1f3(); // virtual void Derived::f3()

    long v_table2_addr_value = *((long *) d + 1); // 类实例内存第2个8字节为 第2个虚函数表地址值
    printf("vtable2 ptr = 0x%lx\n", v_table2_addr_value); // vtable2 ptr = 0x56241e42ac70

    long b2f1_addr_value = *(long *) v_table2_addr_value;
    printf("b2f1() ptr = 0x%lx\n", b2f1_addr_value); // b2f1() ptr = 0x56241e22a1ad
    Fun b2f1 = (Fun) b2f1_addr_value;
    b2f1(); // virtual void Derived::f1()

    long b2f2_addr_value = *((long *) v_table2_addr_value + 1);
    printf("b2f2() ptr = 0x%lx\n", b2f2_addr_value); // b2f2() ptr = 0x56241e22a0c8
    Fun b2f2 = (Fun) b2f2_addr_value;
    b2f2(); // virtual void Base2::f2()

    long b2f3_addr_value = *((long *) v_table2_addr_value + 2);
    printf("b2f3() ptr = 0x%lx\n", b2f3_addr_value); // b2f3() ptr = 0xfffffffffffffff0


    long v_table3_addr_value = *((long *) d + 2); // 类实例内存第3个8字节为 第3个虚函数表地址值
    printf("vtable3 ptr = 0x%lx\n", v_table3_addr_value); // vtable3 ptr = 0x56241e42ac90

    long b3f1_addr_value = *(long *) v_table3_addr_value;
    printf("b3f1() ptr = 0x%lx\n", b3f1_addr_value); // b3f1() ptr = 0x56241e22a1a7
    Fun b3f1 = (Fun) b3f1_addr_value;
    b3f1(); // virtual void Derived::f1()

    long b3f2_addr_value = *((long *) v_table3_addr_value + 1);
    printf("b3f2() ptr = 0x%lx\n", b3f2_addr_value); // b3f2() ptr = 0x56241e22a138
    Fun b3f2 = (Fun) b3f2_addr_value;
    b3f2(); // virtual void Base3::f2()

    return 0;
}

根据上述代码输出结果，可以画出下面内存模型。

由此可以得出以下结论：

1. 有几个基类就有几个虚函数表，且实例中虚函数表地址值存储顺序就是基类继承顺序。
2. 继承类新增的虚函数f3()排在第一个虚函数表中，且在基类虚函数后面。
3. 继承类中重写基类的虚函数f1()，在每个虚函数表中都覆盖相应的虚函数。

寻找被覆盖的虚函数

Derived 类重写基类Base的f1()函数后，那如果想调用基类的被覆盖的虚函数的话，就需要明确类名字调用。

  Derived *d = new Derived();
    d->f1();  // virtual void Derived::f1()
    d->Base::f1();  // virtual void Base::f1()

内存空间中继承类重写的函数存在于虚函数表中原函数的位置，那么原虚函数的位置在哪呢？

到此这篇关于聊一聊C++虚函数表的问题的文章就介绍到这了,更多相关C++虚函数表内容请搜索猪先飞以前的文章或继续浏览下面的相关文章希望大家以后多多支持猪先飞！