Data语意学之虚继承和虚函数对C++对象内存模型造成的影响（类/对象的大小）

最新推荐文章于 2024-10-31 17:49:22 发布
原创 最新推荐文章于 2024-10-31 17:49:22 发布 · 843 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

首先重新回顾一下关于类/对象大小的计算原则：
类大小计算遵循结构体对齐原则

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

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

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

win32 可选的有1， 2， 4， 8， 16
linux 32 可选的有1， 2， 4
类的大小与数据成员有关与成员函数无关
类的大小与静态数据成员无关
虚继承对类的大小的影响
虚函数对类的大小的影响


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

测试环境为：Win32 + Vs2008


一、只出现虚继承的情况

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#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 **)ⅆ
    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++标准规定对对象取地址将始终为对应类型的首地址。


二、只出现虚函数的情况

（一）：一般继承

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#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：虚函数表指针


（二）、钻石继承

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#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分别指向其中一个），分别与它的多态基类对应。


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


 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#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 **)ⅆ
    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 的下面。


注意：如果没有虚继承，则虚函数表会合并，一个类只会存在一个虚函数表和一个虚函数表指针(同个类的对象共享），当然也不会有虚基类表和虚基类表指针的存在。
但如果是钻石继承，那么是会存在两份虚函数表和两份虚函数表指针的。


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


注意：如果没有虚继承，则虚函数表会合并，一个类只会存在一个虚函数表和一个虚函数表指针(同个类的对象共享），当然也不会有虚基类表和虚基类表指针的存在。
但如果是钻石继承，那么是会存在两份虚函数表和两份虚函数表指针的。

深度探索C++对象模型笔记
编程与实战的博客
11-18 1547
一、关于对象C 语言是程序性的，语言本身并没有支持数据和函数之间的关联性C++ 中可能采取抽象数据类型，或者是多层次的类结构完成C++ 的封装并没有增加多少成本，每一个成员函数虽然在cla...
虚函数的工作原理与类的大小
qq_33215865的博客
03-12 445
1、虚函数的作用 虚函数通过动态联编技术，使程序运行时选择正确的虚方法。使用虚函数，会根据对象的类型来调用函数，而不是根据指针类型。 #include&lt;iostream&gt; using namespace std; class A{ public: A(){} virtual void show(){ cout &lt;&lt; "this is A show" &lt...
从零开始学C++之虚继承和虚函数对C++对象内存模型造成的影响（类/对象的大小）
Meditation
07-13 5008
首先重新回顾一下关于类/对象大小的计算原则： 类大小计算遵循结构体对齐原则 第一个数据成员放在offset为0的位置 其它成员对齐至min(sizeof(member)，#pragma pack(n)所指定的值)的整数倍。 整个结构体也要对齐，结构体总大小对齐至各个min中最大值的整数倍。 win32 可选的有1， 2， 4，
【c++】虚函数对对象大小的影响
蝉之洞
09-08 1000
#include "stdafx.h" #include using namespace std; class Base{ public: virtual void fun1(){} }; class Derived1: public Base { public: char a[3]; }; class Derived2: public Base { public: virtual v
C++中对象大小的问题
青青的专栏--C/C++ OOA/D Design Pattern
06-13 557
总结:   1) 类的所有对象都指向一个虚函数表, 也就是说虚函数表是由类来维护的, 在编译的时候就已经确定了   2) 对象的大小,      2.1) 当类中没有虚函数时，并没有一个指针指向虚函数表， 只有当有虚函数的时候才有指针。     2.2) 当类中有静态变量时, 对象的大小不会因为静态变量的而改变, 静态变量并不在对象中     2.3) 对象中只会有非静态的成员变量，
类内存大小
Sky_nnn的博客
04-29 337
首先，平时所声明的类只是一种类型定义，它本身是没有大小可言的。 因此，如果用sizeof运算符对一个类型名操作，那得到的是具有该类型实体的大小。 类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数（这是笼统的说，后面会细说）是不计算在内的。 成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。而我们访问类的成员函数是通过类里面的一个指针实现，而这个指针指向的是一
C++中类对象所占空间的大小
u014023993的专栏
09-01 881
 首先，平时所声明的类只是一种类型定义，它本身是没有大小可言的。 因此，如果用sizeof运算符对一个类型名操作，那得到的是具有该类型实体的大小。 　　 计算一个类对象的大小时的规律： 空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）； 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的； 因此一个对象的大小≥所有非
深度解析C++对象模型与语意学
C++的对象模型是指C++语言中关于对象的结构和行为的实现机制，这是理解C++如何在内存中表示对象和执行操作的关键。 ### 第一章：关于对象 在C++中，对象是类的实例，而类是对象的蓝图。对象可以是变量、数组或者...
C++对象模型总结
10-09
第3章 Data语意学 第4章 Function语意学 第5章 构造、析构、拷贝语意学 第6章 执行期语意学 第7章 站在对象模型的尖端 第8章 C++对象模型总结 8.1 C++对象模型 8.2 单继承 8.2.1 无重写的单继承 8.2.2 有重写的单...
C++对象模型：Function 语意学
最新发布
_
10-31 865
使用C++时，成员函数和非成员函数在性能上应该是等价的。当设计类时，我们不应该因为担心效率问题而避免使用成员函数。实现：编译器会将成员函数转换为一个带有额外this指针参数的非成员函数，这使得成员函数可以直接访问对象的数据成员。成员函数到非成员函数的转换签名修改：首先，成员函数的签名会被修改，在最前面添加一个隐式的this指针作为参数。如果成员函数是const的，那么this指针也会是const。
C++对象模型深度解析：构造、继承与底层机制详解
- Data语意学：着重讲解DataMember的绑定、布局和存取，以及继承对DataMember的影响。这部分内容有助于理解如何组织和管理类的数据成员，以及它们在内存中的位置。 - Function语意学：深入探讨了各种类型的函数调用...
含有虚函数的类对象的空间大小
cike211的专栏
06-07 1244
普通函数不占用内存，只有虚函数会占用一个指针大小的内存，原因是系统用一个指针维护这个类的虚函数表，并且注意这个虚函数无论含有多少项都不会影响类的大小。        在计算类对象占用的空间时只需计算变量所占的内存空间，如果有虚函数的话，还需要加上虚函数的大小
C++类对象大小的计算(三)含有虚函数、虚继承类大小计算
日积月累
10-01 2422
前一篇文章《C++类对象大小的计算(一)常规类大小计算》初步介绍类大小计算后，我们继续来讨论含有虚函数时类的大小。
C++虚继承下带有虚函数的类的大小（含多重虚继承，虚继承后完全覆盖等复杂情况）
chczy1的博客
08-20 1048
带有虚函数的虚继承的对象模型比较复杂，所以来整理一下。以下讨论均在visual studio2017以及64位环境的前提下进行； 1.带有虚函数的类 class A { public: int a_; virtual void foo1() { cout << "A1" << endl; } virtual void foo2() { cout <<...
C++类大小详解
ryanxw growing
04-23 602
类的大小与什么有关系？ 有关因素：普通成员变量，虚函数，继承（单一继承，多重继承，重复继承，虚拟继承） 无关因素：静态成员变量，静态成员函数及普通成员函数 空类 空类即什么都没有的类，按上面的说法，照理说大小应该是0，但是，空类的大小为1，因为空类可以实例化，实例化必然在内存中占有一个位置，因此，编译器为其优化为一个字节大小。 某类继承自空类： class base { }; clas...
C++继承、虚继承、虚函数类的大小问题
热门推荐
jhj735412的专栏
05-18 1万+
一、真空类 class CNull { }; 长度：1 内存结构： ?? 评注：长度其实为0，这个字节作为内容没有意义，可能每次都不一样。   二、空类 class CNull2 { public:     CNull2(){printf("Construct/n");}     ~CNul
C++类对象大小规则总结
ghscarecrow的博客
10-06 999
规则 成员函数不占类对象的内存空间 一个类对象至少占1字节内存空间 成员变量是包含在每个对象中，占字节的 成员函数虽然也写在类定义中，但成员函数不占类对象的字节空间，也就是说，成员函数是跟着类走的，跟类对象没有关系，不管用这个类产生了多少个该类的对象 静态成员变量不计算在对象的sizeof内 普通成员函数和静态成员函数不计算在sizeof内 虚函数不计算在对象的sizeof内，但虚函数会让对象的sizeof增加4字节以容纳指向虚函数表的指针 虚函数表是基于类的 如果类中有多个数据成员，那么为了访问速度和性
C++虚继承下的类大小
Jason_Lee155的博客
04-21 1737
虚拟继承确定是要增加一张虚函数表和一个虚基类指针表嘛
C++ 类对象的内存空间大小浅析
Christo的博客
10-29 1113
一个空的类的内存空间大小 #include "stdafx.h" #include <iostream> #include <vector> #include <algorithm> #include <map> using namespace std; class Base { public: }; int _tmain(int argc, _TCHAR* argv[]) { Base b; int size = sizeof(b); cout.
深度解析C++对象模型及其语意学
第5章“构造、解构、拷贝语意学”覆盖了对象构造、解构和拷贝的语意，特别是纯虚拟函数和虚拟规格的存在如何影响这些语意。 第6章“执行期语意学”着眼于对象的生命周期，从全局对象、局部静态对象到对象数组的构造...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值