从零开始学C++之虚继承和虚函数对C++对象内存模型造成的影响(类/对象的大小)

首先重新回顾一下关于类/对象大小的计算原则:

类大小计算遵循结构体对齐原则

第一个数据成员放在offset为0的位置

其它成员对齐至min(sizeof(member),#pragma pack(n)所指定的值)的整数倍。

整个结构体也要对齐,结构体总大小对齐至各个min中最大值的整数倍。

win32 可选的有1, 2, 4, 8, 16

linux 32 可选的有1, 2, 4

类的大小与数据成员有关与成员函数无关 类的大小与静态数据成员无关 虚继承对类的大小的影响 虚函数对类的大小的影响

下面通过实例来展示虚继承和虚函数对类大小造成的影响。

测试环境为:Win32 + Vs2008

一、只出现虚继承的情况

#include <iostream>
using namespace std;

class BB
{
public :
      int bb_ ;
};

class B1 : virtual public BB
{
public :
      int b1_ ;
};

class B2 : virtual public BB
{
public :
      int b2_ ;
};

class DD : public B1, public B2
{
public :
      int dd_ ;
};

int main (void)
{
      cout<<sizeof (BB)<< endl;
      cout<<sizeof (B1)<< endl;
      cout<<sizeof (DD)<< endl;

      B1 b1 ;
      int** p ;

      cout<<&b1 <<endl;
      cout<<&b1 .bb_<< endl;
      cout<<&b1 .b1_<< endl;

      p = (int **)&b1;
      cout<<p [0][0]<<endl;
      cout<<p [0][1]<<endl;

      DD dd ;
      cout<<&dd <<endl;
      cout<<&dd .bb_<< endl;
      cout<<&dd .b1_<< endl;
      cout<<&dd .b2_<< endl;
      cout<<&dd .dd_<< endl;
      p = (int **)&dd;
      cout<<p [0][0]<<endl;
      cout<<p [0][1]<<endl;
      cout<<endl ;
      cout<<p [2][0]<<endl;
      cout<<p [2][1]<<endl;

      BB* pp ;

      pp = &dd ;
      dd.bb_ = 10; //对象的内存模型在编译时就已经确定了,否则无法定义类的对象,因为要开辟内存
      int base = pp-> bb_;     // 通过间接访问 (其实pp 已经偏移了20 ),这需要运行时的支持
      cout<<"dd.bb_=" <<base<< endl;

      return 0;
}

从输出的地址和虚基类表成员数据可以画出对象内存模型图:

virtual base table 

本类地址与虚基类表指针地址的差 虚基类地址与虚基类表指针地址的差

virtual base table pointer(vbptr)

从程序可以看出pp是BB* 指针,通过打印pp 的值与&dd 比较可知,

cout<<(void*)&dd<<endl; cout<<(void*)pp<<endl;

pp实际上已经偏移了20个字节,如何实现的呢?先找到首个vbptr,找到虚基类BB地址与虚基类表指针地址的差,也即是20,接着pp偏移20个字节指向了dd对象中的BB部分,然后就访问到了bb_,这是在运行时才做的转换。记住:C++标准规定对对象取地址将始终为对应类型的首地址。

二、只出现虚函数的情况

(一):一般继承

#include <iostream>
using namespace std;

class Base
{
public :
    virtual void Fun1()
    {
        cout << "Base::Fun1 ..." << endl;
    }

    virtual void Fun2()
    {
        cout << "Base::Fun2 ..." << endl;
    }
    int data1_ ;
};

class Derived : public Base
{
public :
    void Fun2 ()
    {
        cout << "Derived::Fun2 ..." << endl;
    }
    virtual void Fun3()
    {
        cout << "Derived::Fun3 ..." << endl;
    }
    int data2_ ;
};

typedef void (* FUNC)(void );

int main (void)
{
    cout << sizeof (Base) << endl;
    cout << sizeof (Derived) << endl;
    Base b ;
    int **p = (int **)& b;
    FUNC fun = (FUNC) p[0][0];
    fun();
    fun = (FUNC )p[0][1];
    fun();
    cout << endl ;

    Derived d ;
    p = (int **)&d;
    fun = (FUNC )p[0][0];
    fun();
    fun = (FUNC )p[0][1];
    fun();
    fun = (FUNC )p[0][2];
    fun();

    return 0;
}

从输出的函数体可以画出对象内存模型图:

vtbl:虚函数表(存放虚函数的函数指针)

vptr:虚函数表指针

从输出可以看出,Derived类继承了Base::Fun1,而覆盖了Fun2,此外还有自己的Fun3。注意,因为Fun3是虚函数,才会出现在虚函数表,如果是一般函数是不会的,因为不用通过vptr间接访问。

(二)、钻石继承

#include <iostream>
using namespace std;

class BB
{
public:
    virtual void vpbb()
    {
        cout << "BB:vpbb().." << endl;
    }
    int bb_;
};
class B1 : public BB
{
public:
    virtual void vpb1()
    {
        cout << "B1:vpb1().." << endl;
    }
    int b1_;
};
class B2 : public BB
{
public:
    virtual void vpb2()
    {
        cout << "B2:vpb2().." << endl;
    }
    int b2_;
};
class DD : public B1, public B2
{
public:
    virtual void vpdd()
    {
        cout << "DD:vpdd().." << endl;
    }
    int dd_;
};

typedef void (* FUNC)(void );

int main()
{
    cout << sizeof(BB) << endl;
    cout << sizeof(B1) << endl;
    cout << sizeof(DD) << endl;
    cout << endl;

    DD dd ;
    cout << &dd << endl;
    cout << &dd.B1::bb_ << endl;
    cout << &dd.B2::bb_ << endl;
    cout << &dd .b1_ << endl;
    cout << &dd .b2_ << endl;
    cout << &dd .dd_ << endl;
    cout << endl;

    B1 b ;
    int **p = (int **)& b;
    FUNC fun = (FUNC) p[0][0];
    fun();
    fun = (FUNC )p[0][1];
    fun();
    cout << endl ;

    p = (int **)&dd
    fun = (FUNC)p[0][0];
    fun();
    fun = (FUNC)p[0][1];
    fun();
    fun = (FUNC)p[0][2];
    fun();

    fun = (FUNC)p[3][0];
    fun();
    fun = (FUNC)p[3][1];
    fun();

    cout << endl;

    return 0;
}

从成员输出的地址和通过虚函数表指针访问到的函数可以画出模型:

DD::vfdd 的位置跟继承的顺序有关,如果DD先继承的是B2, 那么它将跟在B2::vfb2 的下面。

如果派生类是从多个基类继承或者有多个继承分支(从所有根类开始算起),而其中若干个继承分支上出现了多态类,则派生类将从这些分支中的每个分支上继承一个vptr,编译器也将为它生成多个vtable,有几个vptr就生成几个vtable(每个vptr分别指向其中一个),分别与它的多态基类对应。

三、虚继承与虚函数同时出现的情况:

#include <iostream>
using namespace std;

class BB
{
public :
      virtual void vfbb()
     {
           cout<<"BB::vfbb" <<endl;
     }
      virtual void vfbb2()
     {
           cout<<"BB::vfbb2" <<endl;
     }
      int bb_ ;
};

class B1 : virtual public BB
{
public :
      virtual void vfb1()
     {
           cout<<"B1::vfb1" <<endl;
     }
      int b1_ ;
};

class B2 : virtual public BB
{
public :
      virtual void vfb2()
     {
           cout<<"B2::vfb2" <<endl;
     }
      int b2_ ;
};

class DD : public B1, public B2
{
public :
      virtual void vfdd()
     {
           cout<<"DD::vfdd" <<endl;
     }
      int dd_ ;
};

typedef void (* FUNC)(void);

int main (void)
{
      cout<<sizeof (BB)<< endl;
      cout<<sizeof (B1)<< endl;
      cout<<sizeof (DD)<< endl;

      BB bb ;
      int** p ;
      p = (int **)&bb;
      FUNC fun ;
      fun = (FUNC )p[0][0];
      fun();
      fun = (FUNC )p[0][1];
      fun();
      cout<<endl ;


      B1 b1 ;
     
      p = (int **)&b1;
      fun = (FUNC )p[0][0];
      fun();
      fun = (FUNC )p[3][0];
      fun();
      fun = (FUNC )p[3][1];
      fun();

      cout<<p [1][0]<<endl;
      cout<<p [1][1]<<endl;
      cout<<endl ;



      DD dd ;
      p = (int **)&dd;
      fun = (FUNC )p[0][0];
      fun();
      fun = (FUNC )p[0][1]; // DD::vfdd 挂在 B1::vfb1的下面
      fun();
      fun = (FUNC )p[3][0];
      fun();
      fun = (FUNC )p[7][0];
      fun();
      fun = (FUNC )p[7][1];
      fun();
     
      cout<<p [1][0]<<endl;
      cout<<p [1][1]<<endl;
      cout<<p [4][0]<<endl;
      cout<<p [4][1]<<endl;


      return 0;
}

从输出的虚基类表成员数据和虚函数体可以画出对象内存模型图:

上图中vfdd 出现的位置跟继承的顺序有关,如果DD先继承的是B2,那么它将跟在vfb2 的下面。

注意:如果没有虚继承,则虚函数表会合并,一个类只会存在一个虚函数表和一个虚函数表指针(同个类的对象共享),当然也不会有虚基类表和虚基类表指针的存在。

但如果是钻石继承,那么是会存在两份虚函数表和两份虚函数表指针的。

参考:

《深入探索C++对象模型》

C++ primer 第四版 Effective C++ 3rd C++编程规范

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏数据结构与算法

1265. [NOIP2012] 同余方程

1265. [NOIP2012] 同余方程 ★☆   输入文件:mod.in   输出文件:mod.out 简单对比 时间限制:1 s   内存限制:128 M...

3286
来自专栏数据结构与算法

洛谷 P1313 计算系数

题目描述 给定一个多项式 ,请求出多项式展开后 项的系数。 输入输出格式 输入格式: 输入文件名为factor.in。 共一行,包含5 个整数,分别为 a...

3023
来自专栏数据结构与算法

04:垂直直方图

4:垂直直方图 总时间限制: 1000ms 内存限制: 65536kB描述 输入4行全部由大写字母组成的文本,输出一个垂直直方图,给出每个字符出现的次数。注...

3507
来自专栏bboysoul

1067: 成绩评估

描述:我们知道,高中会考是按等级来的。90~100为A; 80~89为B; 70~79为C; 60~69为D; 0~59为E。 编写一个程序,对输入的...

642
来自专栏C语言及其他语言

【每日一题】问题 1218: 排列

关注我们 题目描述 Ray又对数字的列产生了兴趣: 现有四张卡片,用这四张卡片能排列出很多不同的4位数,要求按从小到大的顺序输出这些4位数。 输入 ...

2568
来自专栏Crossin的编程教室

【每周一坑】杨辉三角形

杨辉三角形,也称帕斯卡三角,其定义为:顶端是 1,视为(row0).第1行(row1)(1&1)两个1,这两个1是由他们上头左右两数之和 (不在三角形内的数视为...

2564
来自专栏LeetCode

LeetCode <dp>343. Integer Break

Given a positive integer n, break it into the sum of at least two positive integ...

510
来自专栏生信小驿站

NA、Inf、NaN、NULL等值处理

这几个都是R语言里面的特殊值,都是R的保留字(reserved words)。它们的意义分别为:

713
来自专栏程序生活

hdu-1098 Ignatius's puzzle(费马小定理)费马小定理同余式证明应用Ignatius's puzzle运行结果

费马小定理 费马小定理是数论中的一个定理:假如a是一个整数,p是一个质数,那么 ? 是p的倍数,可以表示为 ? 如果a不是p的倍数,这个定理也可以写成(同余式...

3624
来自专栏深度学习之tensorflow实战篇

python 中numpy基本方法总结可以类推tensorflow

一、数组方法 创建数组:arange()创建一维数组;array()创建一维或多维数组,其参数是类似于数组的对象,如列表等 反过来转换则可以使用numpy.n...

4555

扫码关注云+社区