C++中的虚表

原创

2022-11-22

4812

C++中为了实现多态，使用的是虚表。
首先我们看一个简单的例子，代码如下：

#include <iostream>
#include "stdlib.h"

class BaseClass
{
public:
    BaseClass() {}
    `~BaseClass(){}

    virtual void runPrint(void) {
        std::cout << "Run BaseClass Function!" << std::endl;
    }

    virtual void runPrint2(void) {
        std::cout << "Run BaseClass Function2!" << std::endl;
    }

    int m_Number = 10;
};

int main(int argc, char** argv)
{
    BaseClass a;
    a.runPrint();

    system("pause");
    return 0;
}

我们在 a 的位置下一个断点，看一下a中的内容，如下图所示

这个 __vfptr 就是对象a的虚表，存储着数据的虚函数列表
这个表的指针存储在对象的首地址
重写虚函数时，子类的函数会替换虚表中对应的函数

下面是一个继承的列子：

class MyClass : public BaseClass
{
public:
    MyClass(){}
    ~MyClass(){}

    void runPrint(void) override {
        std::cout << "Run MyClass Function!" << std::endl;
    }
};

接下来我们重写改写一下这个子类

class MyClass : public BaseClass
{
public:
    MyClass(){}
    ~MyClass(){}

    void runPrint(void) override {
        std::cout << "Run MyClass Function!" << std::endl;
    }

    virtual void runPrint3(void) {
        std::cout << "Run MyClass Function3" << std::endl;
    }
};

我们用图表示类中虚表的存储

为了证明这个存储方式是正确的，我们做如下的代码

typedef void(*Fun)(void);
BaseClass *pD = new MyClass;

void** pArray = (void**)(*((int**)(pD)));
Fun f = (Fun)pArray[0];     // MyClass::runPrint
f();

f = (Fun)pArray[1];	        // BaseClass::runPrint2
f();

f = (Fun)pArray[2];         // MyClass::runPrint3
f();

运行结果如下：
Run MyClass Function!
Run BaseClass Function2!
Run MyClass Function3

这里值得说明的是，对于菱形的继承方式，如这种方式继承
基类 A
A <-B, A<-C B继承A，C继承A
B<-D，C<-D D继承B和C

代码如下：

#include 
#include "stdlib.h"

class ClassA
{
public:
    ClassA() {}
    ~ClassA(){}

    virtual void runPrint(void) {
        std::cout << "Run ClassA Function!" << std::endl;
    }

    virtual void runPrint2(void) {
        std::cout << "Run ClassA Function2!" << std::endl;
    }

    int m_Number = 10;
};

class ClassB : public ClassA
{
public:
    ClassB(){}
    ~ClassB(){}

    void runPrint(void) override {
        std::cout << "Run ClassB Function!" << std::endl;
    }

    virtual void runPrint3(void) {
        std::cout << "Run ClassB Function3" << std::endl;
    }
};

class ClassC : public ClassA
{
public:
    ClassC() {}
    ~ClassC() {}

    void runPrint(void) override {
        std::cout << "Run ClassC Function!" << std::endl;
    }

    virtual void runPrint4(void) {
        std::cout << "Run ClassC Function4" << std::endl;
    }
};

class ClassD : public ClassB, public ClassC
{
public:
    ClassD() {}
    ~ClassD() {}

    void runPrint(void) override {
        std::cout << "Run ClassD Function!" << std::endl;
    }

    virtual void runPrint5(void) {
        std::cout << "Run ClassD Function5" << std::endl;
    }
};

typedef void(*Fun)(void);

int main(int argc, char** argv)
{
    ClassD *pD = new ClassD;

    void** pArray = (void**)(*((int**)(pD)));
    Fun f = (Fun)pArray[0];     // MyClass::runPrint
    f();

    f = (Fun)pArray[1];         // BaseClass::runPrint2
    f();

    f = (Fun)pArray[2];         // MyClass::runPrint3
    f();

    f = (Fun)pArray[3];         // MyClass::runPrint3
    f();

    system("pause");
    return 0;
}

运行结果如下：
Run ClassD Function!
Run ClassA Function2!
Run ClassB Function3
Run ClassD Function5

在内存中存储如下