C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++虚函数表

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()其内存模型为

在这里插入图片描述

由此可以得出以下结论：

多基类继承 虚函数表

继承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个虚函数表指针。
下面通过代码来检查一下内存数据。

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

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

在这里插入图片描述

由此可以得出以下结论：

寻找被覆盖的虚函数

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

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

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

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容！

您可能感兴趣的文章:
阅读全文