C++：类的内存布局

已于 2022-12-11 11:21:55 修改
阅读量543 收藏 1
点赞数 1
分类专栏： C++ 基础 文章标签： c++
于 2022-12-11 11:01:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/you_fathe/article/details/128272673
版权

文章目录


建议先了解 C++ 继承与多态的相关知识，再来阅读。也可以看我之前写过的： C++：继承 和 C++：多态，这两篇文章。

1、虚的含义

虚的含义是存在、间接、共享，在虚函数和虚拟继承中，其含义分别解释为

虚函数

  • 存在：虚函数是存在的

  • 间接：虚函数必须通过虚函数表在运行期间调用

  • 共享：基类指针会共享被派生类重定义的虚函数

虚拟继承

  • 存在：虚继承体系和虚基类确实存在

  • 间接：当访问虚基类的成员时必须通过虚基表间接完成

  • 共享：虚基类会在虚继承体系中被共享，而不会出现多份拷贝

虚函数的实现机制

  • 虚函数指针 vfptr：指向虚函数表。位于派生类内存空间的起始。
  • 虚函数表：存放虚函数入口地址。

虚拟继承的实现机制

  • 虚基指针 vbptr：指向虚基表。虚基类位于派生类内存空间的末尾。
  • 虚基表：存放虚基类对象的地址。

2、单基继承

2.1、单继承

基类位于派生类存储空间的起始。

在这里插入图片描述

2.2、单虚继承

虚基类位于派生类存储空间的末尾。

在这里插入图片描述

1>class B	size(16):
1>	+---          
1> 0	| {vbptr} // 派生类的虚基指针
1> 4	| _ib               
1>	+---
1>	+--- (virtual base A) // 虚基类位于派生类存储空间的最末尾
1> 8	| {vfptr} 		 // 虚基类的虚函数指针
1>12	| _ia
1>	+---

// 派生类的虚基表
1>B::$vbtable@: 
1> 0	| 0  		  // 距离派生类对象首地址的偏移
1> 1	| 8 (Bd(B+0)A) // 距离虚基类对象的首地址的偏移
1>

// 虚基类的虚函数表
1>B::$vftable@:  // 虚函数表，存放基类虚函数的地址
1>	    | -8     // 距离派生类对象首地址的偏移
1> 0	| &B::f  // 指向虚函数的地址

2.3、单虚继承 + 虚函数

派生类拥有自己的虚函数

在这里插入图片描述

1>class B	size(20):
1>	+---
1> 0	| {vfptr} // 派生类的虚函数指针
1> 4	| {vbptr} // 派生类的虚基指针
1> 8	| _ib
1>	+---
1>	+--- (virtual base A) // 虚基类
1>12	| {vfptr} 
1>16	| _ia
1>	+---
// 派生类的虚函数表
1>B::$vftable@B@: 
1>		| &B_meta
1>		|  0
1> 0	| &B::fb2 // 派生类自定义的虚函数
1>
// 虚基类的虚基表
1>B::$vbtable@:  
1> 0	| -4
1> 1	| 8 (Bd(B+4)A) 
1>
// 虚基类的虚函数表
1>B::$vftable@A@: 
1>	    | -12
1> 0	| &B::f

2.4、测试代码

#pragma vtordisp(off)
#include <iostream>
using std::cout;
using std::endl;

class A {
public:
	A() : _ia(10) {}
	virtual void f() 
    { cout << "A::f()" << endl; }
private:
	int _ia;
};

// 测试代码：在类B上修改相应的代码
// 测试1：单继承，不带虚函数，注释掉所有的virtual关键字
// 测试2：单虚拟继承，不带虚函数，注释掉类内的所有virtual关键字
// 测试3：单虚拟继承，带虚函数，打开类内的virtual关键字
class B: virtual public A{
public:
	B() : _ib(20) {}
	void fb()
	{ cout << "A::fb()" << endl; }
	virtual void f()
	{ cout << "B::f()" << endl; }
	virtual void fb2()
    { cout << "B::fb2()" << endl;}

private:
	int _ib;
};

int main() {
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	B b;

	return 0;
}

3、多基继承

3.1、多继承 + 虚函数

  • 每个基类都有自己的虚函数表
  • 内存布局中，其基类的布局按照基类被声明时的顺序进行排列
  • 派生类如果有自己的虚函数，会被加入到第一个虚函数表之中
  • 派生类会覆盖基类的虚函数，只有第一个虚函数表中存放的是虚函数的入口地址。其他的虚函数表中存放的是一条跳转指令，指向当前派生类对象的起始地址。

测试：多基继承 + 基类虚函数 + 派生类自定义虚函数

在这里插入图片描述

1>class Derived	size(28):
1>	+---
1> 0	| +--- (base class Base1)
1> 0	| | {vfptr}
1> 4	| | _iBase1
1>	| +---
1> 8	| +--- (base class Base2)
1> 8	| | {vfptr}
1>12	| | _iBase2
1>	| +---
1>16	| +--- (base class Base3)
1>16	| | {vfptr}
1>20	| | _iBase3
1>	| +---
1>24	| _iDerived
1>	+---
    
1>Derived::$vftable@Base1@:
1>	    | &Derived_meta
1>	    |  0
1> 0	| &Derived::f  // 派生类重写基类的虚函数
1> 1	| &Base1::g
1> 2	| &Base1::h
1> 3	| &Derived::g1 // 派生类自定义的虚函数
    
1>Derived::$vftable@Base2@:
1>	| -8
1> 0	| &thunk: this-=8; goto Derived::f  // 跳转指令
1> 1	| &Base2::g
1> 2	| &Base2::h
    
1>Derived::$vftable@Base3@:
1>	    | -16
1> 0	| &thunk: this-=16; goto Derived::f // 跳转指令
1> 1	| &Base3::g
1> 2	| &Base3::h

3.2、虚拟多继承 + 虚函数

测试：多基继承 + 基类虚函数 + 派生类自定义虚函数

注：若有继承的基类，则复用基类的第一个虚函数表；若没有继承的基类，如本例中只有虚基类，则派生类自定义虚函数表。

在这里插入图片描述

1>class Derived	size(36):
1>	+---
1> 0	| {vfptr}  // 虚函数指针
1> 4	| {vbptr}  // 虚基指针
1> 8	| _iDerived
1>	+---
1>	+--- (virtual base Base1)
1>12	| {vfptr}
1>16	| _iBase1
1>	+---
1>	+--- (virtual base Base2)
1>20	| {vfptr}
1>24	| _iBase2
1>	+---
1>	+--- (virtual base Base3)
1>28	| {vfptr}
1>32	| _iBase3
1>	+---
    
// 派生类的虚函数表
1>Derived::$vftable@Derived@:
1>	| &Derived_meta
1>	|  0
1> 0	| &Derived::g1
    
// 派生类的虚基表
1>Derived::$vbtable@: 
1> 0	| -4  
1> 1	| 8 (Derivedd(Derived+4)Base1)  // 虚基类 base1 的地址
1> 2	| 16 (Derivedd(Derived+4)Base2) // 虚基类 base2 的地址
1> 3	| 24 (Derivedd(Derived+4)Base3) // 虚基类 base3 的地址
    
1>Derived::$vftable@Base1@:
1>	| -12
1> 0	| &Derived::f  // 派生类重写虚基类的虚函数，override
1> 1	| &Base1::g
1> 2	| &Base1::h
    
1>Derived::$vftable@Base2@:
1>	| -20
1> 0	| &thunk: this-=8; goto Derived::f
1> 1	| &Base2::g
1> 2	| &Base2::h
    
1>Derived::$vftable@Base3@:
1>	| -28
1> 0	| &thunk: this-=16; goto Derived::f
1> 1	| &Base3::g
1> 2	| &Base3::h

3.3、测试代码

#include <iostream>

using std::cout;
using std::endl;

class Base1 {
public:
	Base1() : _iBase1(10) {}

	virtual void f()
    { cout << "Base1::f()" << endl; }

	virtual void g()
	{ cout << "Base1::g()" << endl; }

	virtual void h()
	{ cout << "Base1::h()" << endl; }
private:
	int _iBase1;
};

class Base2{
public:
	Base2() : _iBase2(100) {}

	virtual void f()
	{ cout << "Base2::f()" << endl; }

	virtual void g()
	{ cout << "Base2::g()" << endl; }

	virtual void h()
	{ cout << "Base2::h()" << endl; }
private:
	int _iBase2;
};

class Base3 {
public:
	Base3() : _iBase3(1000) {}

	virtual void f()
	{ cout << "Base3::f()" << endl; }

	virtual void g()
	{ cout << "Base3::g()" << endl; }

	virtual void h()
	{ cout << "Base3::h()" << endl; }
private:
	int _iBase3;
};


class Derived
	: /*virtual*/ public Base1
	, /*virtual*/ public Base2
	, /*virtual*/ public Base3
{
public:
	Derived() : _iDerived(10000) {}
	void f()
	{ cout << "Derived::f()" << endl; }

	virtual void g1()
	{ cout << "Derived::g1()" << endl; }

private:
	int _iDerived;
};

int main(void) {
	Derived d;
	Base2* pBase2 = &d;
	Base3* pBase3 = &d;
	Derived* pDerived = &d;

	pBase2->f();
	cout << "sizeof(d) = " << sizeof(d) << endl;

	cout << "&Derived = " << &d << endl;   
	cout << "pBase2 = " << pBase2 << endl; 
	cout << "pBase3 = " << pBase3 << endl; 

	return 0;
}

4、菱形继承

4.1、菱形继承

基类 B 出现存储二义性，拷贝了两份相同的。

在这里插入图片描述

class D	size(48):
1>	+---
1> 0	| +--- (base class B1)
1> 0	| | +--- (base class B)
1> 0	| | | {vfptr}
1> 4	| | | _ib
1> 8	| | | _cb 
1>  	| | | <alignment member> (size=3) // 内存对齐
1>	| | +---
1>12	| | _ib1
1>16	| | _cb1
1>  	| | <alignment member> (size=3)
1>	| +---
1>20	| +--- (base class B2)
1>20	| | +--- (base class B)
1>20	| | | {vfptr}
1>24	| | | _ib
1>28	| | | _cb
1>  	| | | <alignment member> (size=3)
1>	| | +---
1>32	| | _ib2
1>36	| | _cb2
1>  	| | <alignment member> (size=3)
1>	| +---
1>40	| _id
1>44	| _cd
1>  	| <alignment member> (size=3)
1>	+---
1>D::$vftable@B1@:
1>	| &D_meta
1>	|  0
1> 0	| &D::f
1> 1	| &B::Bf
1> 2	| &D::f1
1> 3	| &B1::Bf1
1> 4	| &D::Df
1>D::$vftable@B2@:
1>	| -20
1> 0	| &thunk: this-=20; goto D::f
1> 1	| &B::Bf
1> 2	| &D::f2
1> 3	| &B2::Bf2

4.2、菱形虚拟继承

虚拟继承后，基类 B 只拷贝了一次。

在这里插入图片描述

1>class D	size(52):
1>	+---
1> 0	| +--- (base class B1)
1> 0	| | {vfptr}
1> 4	| | {vbptr}
1> 8	| | _ib1
1>12	| | _cb1
1>  	| | <alignment member> (size=3)
1>	| +---
1>16	| +--- (base class B2)
1>16	| | {vfptr}
1>20	| | {vbptr}
1>24	| | _ib2
1>28	| | _cb2
1>  	| | <alignment member> (size=3)
1>	| +---
1>32	| _id
1>36	| _cd
1>  	| <alignment member> (size=3)
1>	+---
1>	+--- (virtual base B)
1>40	| {vfptr}
1>44	| _ib
1>48	| _cb
1>  	| <alignment member> (size=3)
1>	+---
    
1>D::$vftable@B1@:
1>	| &D_meta
1>	|  0
1> 0	| &D::f1
1> 1	| &B1::Bf1
1> 2	| &D::Df
1>D::$vftable@B2@:
1>	| -16
1> 0	| &D::f2
1> 1	| &B2::Bf2
1>D::$vbtable@B1@:
1> 0	| -4  
1> 1	| 36 (Dd(B1+4)B) 
1>D::$vbtable@B2@:
1> 0	| -4
1> 1	| 20 (Dd(B2+4)B)
1>D::$vftable@B@:
1>	| -40
1> 0	| &D::f
1> 1	| &B::Bf

4.3、测试代码

#include <iostream>
using std::cout;
using std::endl;

class B {
public:
	B() : _ib(10), _cb('B') {}

	virtual void f()
	{ cout << "B::f()" << endl; }

	virtual void Bf()
	{ cout << "B::Bf()" << endl; }

private:
	int _ib;
	char _cb;
};

class B1 : virtual public B {
public:
	B1() : _ib1(100), _cb1('1') {}

	virtual void f()
	{ cout << "B1::f()" << endl; }

#if 1
	virtual void f1()
	{ cout << "B1::f1()" << endl; }
	virtual void Bf1()
	{ cout << "B1::Bf1()" << endl; }
#endif

private:
	int _ib1;
	char _cb1;
};

class B2 : virtual public B {
public:
	B2() : _ib2(1000), _cb2('2') {}

	virtual void f()
	{ cout << "B2::f()" << endl; }
#if 1
	virtual void f2()
	{ cout << "B2::f2()" << endl; }
	virtual void Bf2()
	{ cout << "B2::Bf2()" << endl; }
#endif
private:
	int _ib2;
	char _cb2;
};

class D : public B1, public B2 {
public:
	D() : _id(10000), _cd('3') {}

	virtual void f()
	{ cout << "D::f()" << endl; }

#if 1
	virtual void f1()
	{ cout << "D::f1()" << endl; }
	virtual void f2()
	{ cout << "D::f2()" << endl; }

	virtual void Df()
	{ cout << "D::Df()" << endl; }
#endif
private:
	int _id;
	char _cd;
};

int main(void) {
	D d;
	cout << sizeof(d) << endl;
	return 0;
}

5、效率分析

实际使用过程中，减少使用多重继承、虚拟继承，因为对内存消耗大。

摸鱼呀
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VS2022查看C++类内存布局
qq_33274387的博客
10-04 524
本来想试着在VS中直接查看的，但是输出很快，根本看不到，不得已采用此方法。其中ABCD是自己的类名，中间没有空格。环境 64位 VS2022 默认编译器。从繁杂的输出中查看类的内存布局。跳转到当前.cpp路径。
C++对象的内存布局
03-03
不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些内容没有涉及：1）...
C++类对象的内存布局
远行's Blog
01-06 948
一、内存对齐 C++的对象都会进行内存对齐，所谓内存对齐，指的是对象的地址和大小都会对齐到n的倍数上。比如按照4对齐，那么对象的地址会是4的倍数，对象的大小也是4的倍数。究其原因是，机器在内存对齐的地址上访问数据更快，可以一起取出数据；如果数据存在在不对齐的地址上，需要换成2次对齐地址上的取数据，再组合出原始数据；而且，部分机器根本没有取非对齐的数据。 1.1 默认对齐 class OrdinaryClassWithMemoryPack { public: int intA; short
C++类的内存布局
FinixLei的专栏 (https://github.com/FinixLei)
04-18 1657
关于C++中类的内存布局，是比较基础而重要的一个内容。先转一篇老文章，因其使用了Visual Studio的特殊功能而能够写得很简单清晰，不过当时作者用的应该是32机器，故指针大小是4字节而不是8字节。 笔者手头没有Visual Studio，故转载之。也可以按陈皓早年的文章用打印地址的方式分析。不过因为本文的方式非常清晰易懂，故还是想转载下这篇。遇到与64位的不同处，本文会略作说明。 本文对原文略作了一些增删： 增加了前2节，对第3节做了不少的删减合并与结构调整，不过基本保留了原图与代码。 原文地址：
[C++] 内存布局完整解读
wangdsh的博客
04-19 1428
右值引用和移动语义：虽然这些特性主要影响临时对象的处理和函数参数的传递，但它们也可能间接影响内存布局，因为它们允许更高效的资源转移和避免不必要的复制。总之，C++11在内存布局方面提供了更多的控制和标准化，使得开发者能够更精确地管理数据结构在内存中的排列，同时也提高了代码的可移植性和性能。继承和多重继承：在多重继承中，基类的数据成员会先于派生类的数据成员排列，且每个基类的数据成员会按照它们在基类中的顺序排列。统一的内存对齐模型：C++11提供了跨编译器和平台的一致内存对齐模型，这有助于提高代码的可移植性。
浅析C++类的内存布局
冯Jungle的个人博客
06-11 791
之前Jungle写过一篇文章《探究C++：虚函数表究竟怎么回事？》，主要xiang
C++内存布局(一)
Mr.Sugarcane
12-19 441
C++内存布局
c++类内存布局
lichao201005的专栏
04-01 1202
一、普通继承 1、先获取到对象a1的地址，通过地址查看内存，如下： 可知内存布局如下： 父类成员变量 子类成员变量 二、父类含有虚函数 可见内存布局如下： 虚函数表指针 父类成员变量 子类成员变量 三、虚基类 虚继承的情况下，对象a1的大小为12字节，是因为前四字节是虚基表地址(区别于虚函数地址)。 虚基表第二个四字节是虚基表变量的偏移量， 即A1的内存地址：也就是说虚基表地址要偏移8个字节才能找打虚基类的变量 虚基表地址 A1成员变量 ..
c++的map的内存布局
https://gitcode.net/liuyuan185442111
01-06 734
最后end()指向的是_M_header，其数据部分正好从_M_node_count的位置开始，it->first正好是_M_node_count的位置，it->second则是p的低4字节。有一个指针偶尔会置成0xffffffff，大佬查了几天发现是由于对map的end迭代器进行了错误操作导致的。_Rb_tree_key_compare里有一个_Compare类型的成员变量，std::less没有成员变量，如果使用默认的内存分配器，_Node_allocator里没有成员变量，不占空间。
C++类几种情况的内存布局
蜗牛想飞翔
10-17 3584
关于C++类内存布局的几种情况，需要多熟悉
C++ 内存对象布局
11-08
涉及各种情况下C++对象的sizeof大小，包括单一类对象，继承，重复继承 多继承 单一虚继承 等各种情况下的对象大小。对C++对象内存布局有清楚了解。
C++类继承内存布局详解图（一目了然）
07-24
"C++类继承内存布局详解图" C++类继承内存布局是一种复杂的机制，涉及到类的继承、成员变量的访问、成员函数的访问、虚函数调用、强制转换到基类或虚基类等多个方面。在本文中，我们将从C结构的布局开始，逐步介绍...
深入解析C++ Data Member内存布局
09-05
在C++编程中，了解数据成员（Data Member）的内存布局是至关重要的，因为它直接影响到对象的大小、存储效率以及程序的性能。本篇文章将深入探讨C++中数据成员的内存布局，包括非静态数据成员、静态数据成员、常量...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1220
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
【C++】：红黑树深度剖析 --- 手撕红黑树！
最新发布
2301_77900444的博客
07-25 1748
就是太过追求绝对平衡，比如在插入时要维护其绝对平衡，旋转次数太多，在删除时甚至有可能要一直旋转到根位置，使之性能低下。本篇文章介绍的红黑树也是一种平衡树，是通过改变节点颜色以及旋转操作，使之接近平衡。红黑树比AVL树的用途更加广泛，在一些方面效率甚至要优于AVL树，并且 map/set 的底层封装用的也是红黑树。红黑树的节点结构与AVL树的大致相同，只是AVL树中有节点的颜色，没有平衡因子。//枚举颜色RED,BLACK,_kv(kv){}
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 668
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 279
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
＜＜C++ Primer Plus（第6版）＞＞12.1 动态内存和类：知识记录
gsp1004的博客
07-25 851
虽然原书中提到用等号来初始化值可能会导致调用赋值运算符(多执行赋值的步骤，效率低)，但是我实测并没有此问题。当然，这个结果是符合预期的，毕竟明明是没必要去多执行一次赋值运算符来赋值的。但是不排除别的环境，别的VS版本，甚至在别的优化等级下表现不同。所以建议自行测试。即便如此，还是建议初始化一个对象使用变量后面用括号赋值初始化的值的方式: StringBad ditto(motto);来规避可能的歧义和不确定的执行流程。默认的复制构造函数和默认的赋值运算符都是浅拷贝/浅复制。
C++多态：对象内存布局与动态绑定详解
本文主要探讨了C++中的对象内存布局图示以及多态的相关概念，特别是针对多继承和虚函数的情况。在C++面向对象编程中，多态是一种关键特性，它允许程序员以统一的接口处理不同类型的对象，从而实现代码的灵活性和可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值