前言：文章较长，而且内容相对来说比较枯燥，希望对C++对象的内存布局、虚表指针、虚基类指针等有深入了解的朋友可以慢慢看。本文的结论都在VS2013上得到验证。不同的编译器在内存布局的细节上可能有所不同。文章如果有解释不清、解释不通或疏漏的地方，恳请指出。

一，何为C++对象模型?

引用《深度探索C++对象模型》这本书中的话：

有两个概念可以解释C++对象模型：

语言中直接支持面向对象程序设计的部分。对于各种支持的底层实现机制。

直接支持面向对象程序设计，包括了构造函数、析构函数、多态、虚函数等等，这些内容在很多书籍上都有讨论，也是C++最被人熟知的地方（特性）。而对象模型的底层实现机制却是很少有书籍讨论的。对象模型的底层实现机制并未标准化，不同的编译器有一定的自由来设计对象模型的实现细节。在我看来，对象模型研究的是对象在存储上的空间与时间上的更优，并对C++面向对象技术加以支持，如以虚指针、虚表机制支持多态特性。

二，文章内容简介

这篇文章主要来讨论C++对象在内存中的布局，属于第二个概念的研究范畴。而C++直接支持面向对象程序设计部分则不多讲。

文章主要内容如下：

虚函数表解析。含有虚函数或其父类含有虚函数的类，编译器都会为其添加一个虚函数表,vptr，先了解虚函数表的构成，有助对C++对象模型的理解。虚基类表解析。虚继承产生虚基类表(vbptr)，虚基类表的内容与虚函数表完全不同，我们将在讲解虚继承时介绍虚函数表。对象模型概述：介绍简单对象模型、表格驱动对象模型，以及非继承情况下的C++对象模型。

继承下的C++对象模型。分析C++类对象在下面情形中的内存布局：

单继承：子类单一继承自父类，分析了子类重写父类虚函数、子类定义了新的虚函数情况下子类对象内存布局。多继承：子类继承于多个父类，分析了子类重写父类虚函数、子类定义了新的虚函数情况下子类对象内存布局，同时分析了非虚继承下的菱形继承。虚继承：分析了单一继承下的虚继承、多重基层下的虚继承、重复继承下的虚继承。

理解对象的内存布局之后，我们可以分析一些问题：

C++封装带来的布局成本是多大？

由空类组成的继承层次中，每个类对象的大小是多大？

至于其他与内存有关的知识，我假设大家都有一定的了解，如内存对齐，指针操作等。本文初看可能晦涩难懂，要求读者有一定的C++基础，对概念一有一定的掌握。

三，理解虚函数表3.1.多态与虚表

C++中虚函数的作用主要是为了实现多态机制。多态，简单来说，是指在继承层次中，父类的指针可以具有多种形态——当它指向某个子类对象时，通过它能够调用到子类的函数，而非父类的函数。

class Base {     virtual void print(void);    }class Drive1 :public Base{    virtual void print(void);    }class Drive2 :public Base{    virtual void print(void);    }

Base * ptr1 = new Base; Base * ptr2 = new Drive1;  Base * ptr3 = new Drive2;

ptr1->print(); //调用Base::print()prt2->print();//调用Drive1::print()prt3->print();//调用Drive2::print()

这是一种运行期多态，即父类指针唯有在程序运行时才能知道所指的真正类型是什么。这种运行期决议，是通过虚函数表来实现的。

3.2.使用指针访问虚表

如果我们丰富我们的Base类,使其拥有多个virtual函数：

class Base{public:     Base(int i) :baseI(i){};     virtual void print(void){ cout << "调用了虚函数Base::print()"; }     virtual void setI(){cout<<"调用了虚函数Base::setI()";}     virtual ~Base(){} private:     int baseI; };

当一个类本身定义了虚函数，或其父类有虚函数时，为了支持多态机制，编译器将为该类添加一个虚函数指针（vptr）。虚函数指针一般都放在对象内存布局的第一个位置上，这是为了保证在多层继承或多重继承的情况下能以最高效率取到虚函数表。

当vprt位于对象内存最前面时，对象的地址即为虚函数指针地址。我们可以取得虚函数指针的地址：

Base b(1000);int * vptrAdree = (int *)(&b);  cout << "虚函数指针（vprt）的地址是：\t"<<vptrAdree << endl;

我们运行代码出结果：

我们强行把类对象的地址转换为 int* 类型，取得了虚函数指针的地址。虚函数指针指向虚函数表,虚函数表中存储的是一系列虚函数的地址，虚函数地址出现的顺序与类中虚函数声明的顺序一致。对虚函数指针地址值，可以得到虚函数表的地址，也即是虚函数表第一个虚函数的地址:

    typedef void(*Fun)(void);    Fun vfunc = (Fun)*( (int *)*(int*)(&b));    cout << "第一个虚函数的地址是：" << (int *)*(int*)(&b) << endl;    cout << "通过地址，调用虚函数Base::print()：";    vfunc();

我们把虚表指针的值取出来： ＊(int＊)(&b)，它是一个地址，虚函数表的地址，把虚函数表的地址强制转换成 int* : ( int ＊) ＊( int＊ )( &b )，再把它转化成我们Fun指针类型 ： (Fun )＊(int ＊)＊(int＊)(&b)，这样，我们就取得了类中的第一个虚函数，我们可以通过函数指针访问它。

运行结果：

同理,第二个虚函数setI()的地址为：

(int * )(*(int*)(&b)+1)

同样可以通过函数指针访问它，这里留给读者自己试验。

到目前为止，我们知道了类中虚表指针vprt的由来，知道了虚函数表中的内容，以及如何通过指针访问虚函数表。下面的文章中将常使用指针访问对象内存来验证我们的C++对象模型，以及讨论在各种继承情况下虚表指针的变化，先把这部分的内容消化完再接着看下面的内容。

四，对象模型概述

在C++中，有两种数据成员（class data members）：static 和nonstatic,以及三种类成员函数（class member functions）:static、nonstatic和virtual:

现在我们有一个类Base，它包含了上面这5中类型的数据或函数：

class Base{public:     Base(int i) :baseI(i){};      int getI(){ return baseI; }     static void countI(){};     virtual ~Base(){}     virtual void print(void){ cout << "Base::print()"; } private:    int baseI;    static int baseS;};

那么，这个类在内存中将被如何表示？5种数据都是连续存放的吗？如何布局才能支持C++多态？ 我们的C++标准与编译器将如何塑造出各种数据成员与成员函数呢？

4.1.简单对象模型

说明：在下面出现的图中，用蓝色边框框起来的内容在内存上是连续的。

这个模型非常地简单粗暴。在该模型下，对象由一系列的指针组成，每一个指针都指向一个数据成员或成员函数，也即是说，每个数据成员和成员函数在类中所占的大小是相同的，都为一个指针的大小。这样有个好处——很容易算出对象的大小，不过赔上的是空间和执行期效率。想象一下，如果我们的Point3d类是这种模型，将会比C语言的struct多了许多空间来存放指向函数的指针，而且每次读取类的数据成员，都需要通过再一次寻址——又是时间上的消耗。所以这种对象模型并没有被用于实际产品上。

4.2.表格驱动模型

这个模型在简单对象模型的基础上又添加一个间接层，它把类中的数据分成了两个部分：数据部分与函数部分，并使用两张表格，一张存放数据本身，一张存放函数的地址（也即函数比成员多一次寻址），而类对象仅仅含有两个指针，分别指向上面这两个表。这样看来，对象的大小是固定为两个指针大小。这个模型也没有用于实际应用于真正的C++编译器上。

4.3.非继承下的C++对象模型

概述：在此模型下，nonstatic 数据成员被置于每一个类对象中，而static数据成员被置于类对象之外。static与nonstatic函数也都放在类对象之外，而对于virtual 函数，则通过虚函数表+虚指针来支持，具体如下：

每个类生成一个表格，称为虚表（virtual table，简称vtbl）。虚表中存放着一堆指针，这些指针指向该类每一个虚函数。虚表中的函数地址将按声明时的顺序排列，不过当子类有多个重载函数时例外，后面会讨论。

每个类对象都拥有一个虚表指针(vptr)，由编译器为其生成。虚表指针的设定与重置皆由类的复制控制（也即是构造函数、析构函数、赋值操作符）来完成。vptr的位置为编译器决定，传统上它被放在所有显示声明的成员之后，不过现在许多编译器把vptr放在一个类对象的最前端。关于数据成员布局的内容，在后面会详细分析。

另外，虚函数表的前面设置了一个指向type_info的指针，用以支持RTTI（Run Time Type Identification，运行时类型识别）。RTTI是为多态而生成的信息，包括对象继承关系，对象本身的描述等，只有具有虚函数的对象在会生成。

在此模型下，Base的对象模型如图：

先在VS上验证类对象的布局：

Base b(1000);

可见对象b含有一个vfptr，即vprt。并且只有nonstatic数据成员被放置于对象内。我们展开vfprt：

void testBase( Base&p){    cout << "对象的内存起始地址：" << &p << endl;    cout << "type_info信息:" << endl;    RTTICompleteObjectLocator str = *((RTTICompleteObjectLocator*)*((int*)*(int*)(&p) - 1));      string classname(str.pTypeDescriptor->name);    classname = classname.substr(4, classname.find("@@") - 4);    cout <<  "根据type_info信息输出类名:"<< classname << endl;     cout << "虚函数表地址:" << (int *)(&p) << endl;     //验证虚表    cout << "虚函数表第一个函数的地址：" << (int *)*((int*)(&p)) << endl;    cout << "析构函数的地址:" << (int* )*(int *)*((int*)(&p)) << endl;    cout << "虚函数表中，第二个虚函数即print（）的地址：" << ((int*)*(int*)(&p) + 1) << endl;     //通过地址调用虚函数print（）    typedef void(*Fun)(void);    Fun IsPrint=(Fun)* ((int*)*(int*)(&p) + 1);    cout << endl;    cout<<"调用了虚函数"；    IsPrint(); //若地址正确，则调用了Base类的虚函数print（）    cout << endl;     //输入static函数的地址    p.countI();//先调用函数以产生一个实例    cout << "static函数countI()的地址：" << p.countI << endl;     //验证nonstatic数据成员    cout << "推测nonstatic数据成员baseI的地址：" << (int *)(&p) + 1 << endl;    cout << "根据推测出的地址，输出该地址的值：" << *((int *)(&p) + 1) << endl;    cout << "Base::getI():" << p.getI() << endl; }

结果分析：

通过 (int *)(&p)取得虚函数表的地址

type_info信息的确存在于虚表的前一个位置。通过((int)(int*)(&p) - 1))取得type_infn信息，并成功获得类的名称的Base

虚函数表的第一个函数是析构函数。

虚函数表的第二个函数是虚函数print()，取得地址后通过地址调用它（而非通过对象），验证正确

虚表指针的下一个位置为nonstatic数据成员baseI。

可以看到，static成员函数的地址段位与虚表指针、baseI的地址段位不同。

好的，至此我们了解了非继承下类对象五种数据在内存上的布局，也知道了在每一个虚函数表前都有一个指针指向type_info，负责对RTTI的支持。而加入继承后类对象在内存中该如何表示呢？

五继承下的C++对象模型5.1.单继承

如果我们定义了派生类

class Derive : public Base{public:    Derive(int d) :Base(1000),      DeriveI(d){};    //overwrite父类虚函数    virtual void print(void){ cout << "Drive::Drive_print()" ; }    // Derive声明的新的虚函数        virtual void Drive_print(){ cout << "Drive::Drive_print()" ; }    virtual ~Derive(){}private:    int DeriveI;};

继承类图为：

一个派生类如何在机器层面上塑造其父类的实例呢？在简单对象模型中，可以在子类对象中为每个基类子对象分配一个指针。如下图：

简单对象模型的缺点就是因间接性导致的空间存取时间上的额外负担，优点则是类的大小是固定的，基类的改动不会影响子类对象的大小。

在表格驱动对象模型中，我们可以为子类对象增加第三个指针：基类指针(bptr)，基类指针指向指向一个基类表(base class table),同样的，由于间接性导致了空间和存取时间上的额外负担，优点则是无须改变子类对象本身就可以更改基类。表格驱动模型的图就不再贴出来了。

在C++对象模型中，对于一般继承（这个一般是相对于虚拟继承而言），若子类重写（overwrite）了父类的虚函数，则子类虚函数将覆盖虚表中对应的父类虚函数(注意子类与父类拥有各自的一个虚函数表)；若子类并无overwrite父类虚函数，而是声明了自己新的虚函数，则该虚函数地址将扩充到虚函数表最后（在vs中无法通过监视看到扩充的结果，不过我们通过取地址的方法可以做到，子类新的虚函数确实在父类子物体的虚函数表末端）。而对于虚继承，若子类overwrite父类虚函数，同样地将覆盖父类子物体中的虚函数表对应位置，而若子类声明了自己新的虚函数，则编译器将为子类增加一个新的虚表指针vptr，这与一般继承不同,在后面再讨论。

我们使用代码来验证以上模型：

typedef void(*Fun)(void); int main(){    Derive d(2000);    //[0]    cout << "[0]Base::vptr";    cout << "\t地址：" << (int *)(&d) << endl;        //vprt[0]        cout << "  [0]";        Fun fun1 = (Fun)*((int *)*((int *)(&d)));        fun1();        cout << "\t地址:\t" << *((int *)*((int *)(&d))) << endl;         //vprt[1]析构函数无法通过地址调用，故手动输出        cout << "  [1]" << "Derive::~Derive" << endl;         //vprt[2]        cout << "  [2]";        Fun fun2 = (Fun)*((int *)*((int *)(&d)) + 2);        fun2();        cout << "\t地址:\t" << *((int *)*((int *)(&d)) + 2) << endl;    //[1]    cout << "[2]Base::baseI=" << *(int*)((int *)(&d) + 1);    cout << "\t地址：" << (int *)(&d) + 1;    cout << endl;    //[2]    cout << "[2]Derive::DeriveI=" << *(int*)((int *)(&d) + 2);    cout << "\t地址：" << (int *)(&d) + 2;    cout << endl;    getchar();}

运行结果：

这个结果与我们的对象模型符合。

5.2.多继承5.2.1一般的多重继承（非菱形继承）

单继承中（一般继承），子类会扩展父类的虚函数表。在多继承中，子类含有多个父类的子对象，该往哪个父类的虚函数表扩展呢？当子类overwrite了父类的函数，需要覆盖多个父类的虚函数表吗？

子类的虚函数被放在声明的第一个基类的虚函数表中。

overwrite时，所有基类的print()函数都被子类的print()函数覆盖。

内存布局中，父类按照其声明顺序排列。

其中第二点保证了父类指针指向子类对象时，总是能够调用到真正的函数。

为了方便查看，我们把代码都粘贴过来

class Base{public:     Base(int i) :baseI(i){};    virtual ~Base(){}     int getI(){ return baseI; }     static void countI(){};     virtual void print(void){ cout << "Base::print()"; } private:     int baseI;     static int baseS;};class Base_2{public:    Base_2(int i) :base2I(i){};     virtual ~Base_2(){}     int getI(){ return base2I; }     static void countI(){};     virtual void print(void){ cout << "Base_2::print()"; } private:     int base2I;     static int base2S;}; class Drive_multyBase :public Base, public Base_2{public:     Drive_multyBase(int d) :Base(1000), Base_2(2000) ,Drive_multyBaseI(d){};     virtual void print(void){ cout << "Drive_multyBase::print" ; }     virtual void Drive_print(){ cout << "Drive_multyBase::Drive_print" ; } private:    int Drive_multyBaseI;};

继承类图为：

此时Drive_multyBase 的对象模型是这样的：

我们使用代码验证：

typedef void(*Fun)(void); int main(){    Drive_multyBase d(3000);    //[0]    cout << "[0]Base::vptr";    cout << "\t地址：" << (int *)(&d) << endl;         //vprt[0]析构函数无法通过地址调用，故手动输出        cout << "  [0]" << "Derive::~Derive" << endl;         //vprt[1]        cout << "  [1]";        Fun fun1 = (Fun)*((int *)*((int *)(&d))+1);        fun1();        cout << "\t地址:\t" << *((int *)*((int *)(&d))+1) << endl;          //vprt[2]        cout << "  [2]";        Fun fun2 = (Fun)*((int *)*((int *)(&d)) + 2);        fun2();        cout << "\t地址:\t" << *((int *)*((int *)(&d)) + 2) << endl;      //[1]    cout << "[1]Base::baseI=" << *(int*)((int *)(&d) + 1);    cout << "\t地址：" << (int *)(&d) + 1;    cout << endl;      //[2]    cout << "[2]Base_::vptr";    cout << "\t地址：" << (int *)(&d)+2 << endl;         //vprt[0]析构函数无法通过地址调用，故手动输出        cout << "  [0]" << "Drive_multyBase::~Derive" << endl;         //vprt[1]        cout << "  [1]";        Fun fun4 = (Fun)*((int *)*((int *)(&d))+1);        fun4();        cout << "\t地址:\t" << *((int *)*((int *)(&d))+1) << endl;     //[3]    cout << "[3]Base_2::base2I=" << *(int*)((int *)(&d) + 3);    cout << "\t地址：" << (int *)(&d) + 3;    cout << endl;     //[4]    cout << "[4]Drive_multyBase::Drive_multyBaseI=" << *(int*)((int *)(&d) + 4);    cout << "\t地址：" << (int *)(&d) + 4;    cout << endl;     getchar();}

运行结果：