探索C++对象模型

只说C++对象模型在内存中如何分配这是不现实的,所以这里选择VS 2013作为调试环境具体探讨object在内存中分配情况.目录给出了具体要探讨的所有模型,正文分标题依次讨论.水平有限,如有错误之处请多包涵如若能及时反馈于我请接受我的谢意.

目录

1. 简单对象模型
2. 单继承对象模型
3. 多继承对象模型
4. 菱形多继承对象模型
5. 虚单继承对象模型
6. 虚多继承对象模型
7. 菱形虚多继承对象模型

简单对象模型

首先给出具体的模型和类的代码,然后我们会验证模型是否正确:) 

class base {
public:
    base() :baseData(5) {}
    virtual ~base() {}
    int baseFunc() { std::cout << "base::baseFunc"; return 0; }
    static int sBaseFunc() { std::cout << "base::sBaseFunc"; return 0; }
    virtual int vfunc() { std::cout << "base::vfunc()"; return 0; }
private:
    int baseData;
    static int sBaseData;
};

这个简单的类完备包含了静态类成员函数,类成员函数,类数据成员,静态类数据成员,虚函数.我们可以注意到base类中所有成员函数(指非静态成员函数, 下文同),静态成员函数和静态数据成员都存在于对象内存之外,也就是定义一个对象不会有额外的开销来保存这些内容,这也符合我们的常识.所以这个简单的对象在内存中主要表现为存储非静态数据成员和虚函数.更具体而言一个对象会保存非静态数据成员和一个指向虚函数表的指针(vfptr,如果有虚函数的话),我们常说C++的编译器会偷偷做很多事情这里便是一个例子,这里的vfptr会被编译器在合适的地方安插进代码,这个合适的地方通常就是default
constructor(如果没有显式声明default constructor编译器会合成一个(当然这也得视情况而定),不过这个不再讨论范围内); 下面是详细的验证,

int main() {
    base b;
    //在vs的编译器实现中虚函数表指针放在对象抵首位,所以&b也就相当于取vfptr地址;
    int * vfptr = (int *)(&b);
    //给virtual int vfunc()别名一个函数指针简化代码
    using vfuncType = int(*)();
    //指向虚函数表第一项的指针
    int *vtablePtr = (int*)(*vfptr);
    //vtablePtr+1表示获取虚函数vfunc的地址,因为直接的vtablePtr是指向析构函数
    vfuncType vfunc= vfuncType(*(vtablePtr + 1));
    //调用虚函数,输出base::vfunc()
    (*vfunc)();

    //输出5
    int *dataPtr = (int *)(&b) + 1;
    std::cout << *dataPtr;
    system("pause");
}

值得注意的是vtablePtr-1就是指向type_info,而type_info主要用以支持RTTI,与主题相差较远这里不做赘述.

单继承对象模型

只要明白了简单对象模型接来的单/多继承也就变得很简单了.

class derived : public base {
public:
    derived() :derivedData(10) {}
    virtual int vfunc() { std::cout << "derived::vfunc()"; return 0; }
    virtual void newVF() { std::cout << "derived::newVF();"; }
private:
    int derivedData;
};

可以看到这里x派生类中新增加的newVF虚函数被置于虚函数表最下方,然后如果派生类重写了虚函数就用派生类重写的版本替代基类的版本,其他顺序不变.同样给出验证:

int main() {
    derived d;
    int * vptf = (int *)(&d);
    int * vfptr = (int *)(&d);
    using vfuncType = int(*)();
    using newVFType = void(*)();
    int *vtablePtr = (int*)(*vfptr);
    vfuncType vfunc = vfuncType(*(vtablePtr + 1));
    newVFType nvfunc = newVFType(*(vtablePtr + 2));
    (*vfunc)(); //derived::vfunc()
    (*nvfunc)();//derived::newVF()

    int *baseDataPtr = (int *)(&d) + 1;
    int *derivedDataPtr = (int *)(&d) + 2;
    std::cout << *baseDataPtr<<*derivedDataPtr;
    system("pause");
}

多继承对象模型

模型如下:

为了方便我们这里适当简化class

class base1 {
public:
    base1() :base1Data(5) {}
    virtual int vfunc() { std::cout << "base::vfunc()"; return 0; }
private:
    int base1Data;
};

class base2 {
public:
    base2() :base2Data(5) {}
    virtual int vfunc() { std::cout << "base::vfunc()"; return 0; }
private:
    int base2Data;
};

class derived : public base1, public base2 {
public:
    derived() :derivedData(10) {}
    virtual int vfunc() { std::cout << "derived::vfunc()"; return 0; }
    virtual void newVF() { std::cout << "derived::newVF();"; }
private:
    int derivedData;
};

图片基本上已经把我想说的说完了, 这里只需要注意一下

• 派生类中新定义的虚函数会置于第一个虚函数表最下面而不是两个虚函数表都放置.
• 基类数据成员会放置在指向该基类的虚函数表的指针下面,如果有必要之类还会进行内存alignment.

验证如下

int main() {
    derived d;
    //上帝原谅我这里用下划线
    int *base1_vfptr = (int*)(&d);
    int *base1_dataPtr = (int*)(&d) + 1;
    int *base2_vfptr = (int*)(&d) + 2;
    int *base2_dataPtr = (int*)(&d) + 3;
    int *derived_dataPtr = (int*)(&d) + 4;

    int (*derived_vfunc)() = (int(*)())(*(int*)(*base1_vfptr));
    void(*derived_newVF)() = (void(*)())(*((int*)(*base1_vfptr)+1));
    int(*derived_vfunc1)() = (int(*)())(*(int*)(*base2_vfptr));
    derived_vfunc();
    derived_newVF();
    derived_vfunc1();
    std::cout << *base1_dataPtr << *base2_dataPtr << *derived_dataPtr;
    system("pause");
}

菱形多继承对象模型

class root {
public:
    root() :rootData(1) {}
    virtual int vfunc() { std::cout << "root::vfunc()"; return 0; }
    virtual void print() { std::cout << "root::print()"; }
private:
    int rootData;
};

class base1 :public root {
public:
    base1() :base1Data(2) {}
    virtual int vfunc() { std::cout << "base::vfunc()"; return 0; }
private:
    int base1Data;
};

class base2 :public root {
public:
    base2() :base2Data(3) {}
    virtual int vfunc() { std::cout << "base::vfunc()"; return 0; }
private:
    int base2Data;
};

class derived : public base1, public base2 {
public:
    derived() :derivedData(4) {}
    virtual int vfunc() { std::cout << "derived::vfunc()"; return 0; }
    virtual void newVF() { std::cout << "derived::newVF();"; }
private:
    int derivedData;
};

这里我们root作为基类,然后base1 base2从root上派生出来,最后derived从base1 base2中派生出来实现一个菱形继承.我们看到上图第一个应该关注的是有两个rootData和root::print(),这对于追求效率的C艹是无法容忍的,所以后面引出虚继承解决这个问题(以便引出另一些问题:( ).至于为什么有两个稍微想一下就能明白,在单继承下派生类内存模型会储存基类的数据成员和虚函数,所以这里base1和base2分别储存了rootData和print(),最后derived的多重继承把每个相对于它而言的基类一块一块的放入内存,之所以说是一块一块是因为内存不会把vfptr放一块然后数据成员放一块而是像之前提及的分块处理.

未完待续.