虚表的内存布局（c++）

最新推荐文章于 2025-05-16 14:05:46 发布

风云来

最新推荐文章于 2025-05-16 14:05:46 发布

阅读量2.9k

点赞数 3

本文链接：https://blog.csdn.net/chenjiayi_yun/article/details/8797676

版权

本文详细探讨了C++中虚函数表（V-Table）的工作原理，包括单一继承、多重继承、重复继承和虚拟多重继承四种情况对内存布局的影响。通过实例展示了虚函数表在内存中的位置以及成员变量的顺序。分析了如何通过对象地址获取虚函数表，以理解C++对象的内存组织方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、虚函数表

虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的，简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表有最高的性能——如果有多层继承或是多重继承的情况下）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

static 成员不属于对象, 而是该类所有对象共有.

2、继承类型对虚表的影响

一个类对象的内存布局成员的影响因素：

1）成员变量

2）虚函数（产生虚函数表）

3）单一继承（只继承于一个类）

4）多重继承（继承多个类）

5）重复继承（继承的多个父类中其父类有相同的超类）

6）虚拟继承（使用virtual方式继承，为了保证继承后父类的内存布局只会存在一份）

这是在c++语义方面对对象内部的影响因素.

除此之外，还会有编译器的影响（比如优化），还有字节对齐的影响。

C++对象的内存布局几种情况：

1）单一的一般继承（带成员变量、虚函数、虚函数覆盖）

2）单一的虚拟继承（带成员变量、虚函数、虚函数覆盖）

3）多重继承（带成员变量、虚函数、虚函数覆盖）

4）重复多重继承（带成员变量、虚函数、虚函数覆盖）

5）虚拟多重继承（带成员变量、虚函数、虚函数覆盖）

可以通过对象的地址来取得虚函数表的地址，如：

typedef void(*Fun)(void);
 
Base b;

Fun pFun = NULL;

cout << "虚函数表地址：" << (int*)(&b) << endl;
cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;

// Invoke the first virtual function 
pFun = (Fun)*((int*)*(int*)(&b));
pFun();

我们同样可以用这种方式来取得整个对象实例的内存布局。

因为这些东西在内存中都是连续分布的，我们只需要使用适当的地址偏移量，我们就可以获得整个内存对象的布局。

（1）单一继承

继承关系代码如下：

在这个继承关系中，父类，子类，孙子类都有自己的一个成员变量。

子类覆盖了父类的f()方法，孙子类覆盖了子类的g_child()及其超类的f()。

代码如下：

class Parent {
public:
    int iparent;
    Parent ():iparent (10) {}
    virtual void f() { cout << " Parent::f()" << endl; }
    virtual void g() { cout << " Parent::g()" << endl; }
    virtual void h() { cout << " Parent::h()" << endl; }
 
};
 
class Child : public Parent {
public:
    int ichild;
    Child():ichild(100) {}
    virtual void f() { cout << "Child::f()" << endl; }
    virtual void g_child() { cout << "Child::g_child()" << endl; }
    virtual void h_child() { cout << "Child::h_child()" << endl; }
};
 
class GrandChild : public Child{
public:
    int igrandchild;
    GrandChild():igrandchild(1000) {}
    virtual void f() { cout << "GrandChild::f()" << endl; }
    virtual void g_child() { cout << "GrandChild::g_child()" << endl; }
    virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }
};

我们使用以下程序作为测试程序：（下面程序中，我使用了一个int** pVtab 来作为遍历对象内存布局的指针，这样，我就可以方便地像使用数组一样来遍历所有的成员包括其虚函数表了，在后面的程序中，我也是用这样的方法的，请不必感到奇怪，）

typedef void(*Fun)(void);

GrandChild gc;
int** pVtab = (int**)&gc;
cout << "[0] GrandChild::_vptr->" << endl;
for (int i=0; (Fun)pVtab[0][i]!=NULL; i++){
   pFun = (Fun)pVtab[0][i];
   cout << "    ["<<i<<"] ";
   pFun();
}
cout << "[1] Parent.iparent = " << (int)pVtab[1] << endl;
cout << "[2] Child.ichild = " << (int)pVtab[2] << endl;
cout << "[3] GrandChild.igrandchild = " << (int)pVtab[3] << endl;

其运行结果如下所示：

[0] GrandChild::_vptr->
[0] GrandChild::f()
[1] Parent::g()
[2] Parent::h()
[3] GrandChild::g_child()
[