C++类的成员变量在内存中的布局

最新推荐文章于 2023-12-03 00:06:17 发布
最新推荐文章于 2023-12-03 00:06:17 发布
阅读量308 收藏 3
点赞数 1
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35260390/article/details/119464568
版权

C++类的成员变量在内存中的布局


首先这个内存布局是可以通过编译器在编译的时候进行观测的，使用VC 编译的这个结果类似于图形化 更加直观。

在解决方案的C文件上右键单击 选择属性-》C/C+±》命令行-》然后在底下的其他选项中输入/d1 reportAllClassLayout即可。然后在写完代码后直接用生成选项进行编译就能得到类的内存布局。

单独一个类，包含了虚函数

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};

输出结果是

>class Base	size(12):
1>		+---
1> 0	| {vfptr}		//这是指向虚函数的指针
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

子类public继承父类，并添加了一个新的虚函数

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};

class DerivedClass :  public Base {
	int c;
public:
	virtual void Derivedcommonfunction();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass	size(16):
1>		+---
1> 0	| +--- (base class Base)
1> 0	| | {vfptr}
1> 4	| | a
1> 8	| | b
1>		| +---
1>12	| c
1>		+---
1>DerivedClass::$vftable@:
1>		| &DerivedClass_meta
1>		|  0
1> 0	| &Base::VirtualFunction					// 因为没有修改过父类的虚函数 所以这个还是指向父类虚函数的位置
1> 1	| &DerivedClass::Derivedcommonfunction	// 这是在父类的虚函数表后面添加的子类的虚函数
1>DerivedClass::Derivedcommonfunction this adjustor: 0

如果是子类public继承 并重写了父类虚函数

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};


class DerivedClass :  public Base {
	int c;
public:
	virtual void VirtualFunction();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass	size(16):
1>		+---
1> 0	| +--- (base class Base)
1> 0	| | {vfptr}
1> 4	| | a
1> 8	| | b
1>		| +---
1>12	| c
1>		+---
1>DerivedClass::$vftable@:
1>		| &DerivedClass_meta
1>		|  0
1> 0	| &DerivedClass::VirtualFunction	// 因为子类重写了父类的这个虚函数，所以在这里指向了其他位置，但是没有被重写的虚函数是不受影响的
1>DerivedClass::VirtualFunction this adjustor: 0

如果子类是virtual public继承父类，并且重写父类虚函数

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};


class DerivedClass : virtual  public Base {
	int c;
public:
	virtual void VirtualFunction();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass	size(20):
1>		+---
1> 0	| {vbptr}		// 子类的虚函数指针
1> 4	| c
1>		+---
1>		+--- (virtual base Base)
1> 8	| {vfptr}	// 父类的虚函数指针
1>12	| a
1>16	| b
1>		+---
1>DerivedClass::$vbtable@:
1> 0	| 0
1> 1	| 8 (DerivedClassd(DerivedClass+0)Base)		// 这个应该是定位到了父类的虚函数表，因为是重写父类虚函数
1>DerivedClass::$vftable@:
1>		| -8					//  这个可能是父类虚函数指针到子类虚函数指针的偏移
1> 0	| &DerivedClass::VirtualFunction		
1>DerivedClass::VirtualFunction this adjustor: 8

1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base       8       0       4 0

子类virtual public继承父类之后，添加新的虚函数

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};


class DerivedClass : virtual  public Base {
	int c;
public:

	virtual void Derivedcommonfunction1();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass	size(24):
1>		+---
1> 0	| {vfptr}   // 指向子类自己的虚函数表
1> 4	| {vbptr}	 // 这个感觉是专门用来指向父类虚函数指针的，因为他的表里总是指向父类虚函数表
1> 8	| c
1>		+---
1>		+--- (virtual base Base)
1>12	| {vfptr}		// 指向父类的虚函数表
1>16	| a
1>20	| b
1>		+---
1>DerivedClass::$vftable@DerivedClass@:
1>		| &DerivedClass_meta
1>		|  0
1> 0	| &DerivedClass::Derivedcommonfunction1
1>DerivedClass::$vbtable@:
1> 0	| -4
1> 1	| 8 (DerivedClassd(DerivedClass+4)Base)		
1>DerivedClass::$vftable@Base@:
1>		| -12
1> 0	| &Base::VirtualFunction
1>DerivedClass::Derivedcommonfunction1 this adjustor: 0

1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base      12       4       4 0

以virtual public继承基类，然后以public方式多继承（不自定义虚函数）

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};

class DerivedClass1 : virtual  public Base {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

class DerivedClass2 : virtual  public Base {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

class DerivedClass3 : public DerivedClass1,public DerivedClass2 {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass1	size(24):
1>		+---
1> 0	| {vfptr}
1> 4	| {vbptr}
1> 8	| c
1>		+---
1>		+--- (virtual base Base)
1>12	| {vfptr}
1>16	| a
1>20	| b
1>		+---
1>DerivedClass1::$vftable@DerivedClass1@:
1>		| &DerivedClass1_meta
1>		|  0
1> 0	| &DerivedClass1::Derivedcommonfunction1
1>DerivedClass1::$vbtable@:
1> 0	| -4
1> 1	| 8 (DerivedClass1d(DerivedClass1+4)Base)
1>DerivedClass1::$vftable@Base@:
1>		| -12
1> 0	| &Base::VirtualFunction
1>DerivedClass1::Derivedcommonfunction1 this adjustor: 0
1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base      12       4       4 0

...//DerivedClass2 和 DerivedClass1	是一样的 这里省略了

1>class DerivedClass3	size(40):
1>		+---
1> 0	| +--- (base class DerivedClass1)
1> 0	| | {vfptr}
1> 4	| | {vbptr}
1> 8	| | c
1>		| +---
1>12	| +--- (base class DerivedClass2)
1>12	| | {vfptr}
1>16	| | {vbptr}
1>20	| | c
1>		| +---
1>24	| c
1>		+---
1>		+--- (virtual base Base)
1>28	| {vfptr}
1>32	| a
1>36	| b
1>		+---
1>DerivedClass3::$vftable@DerivedClass1@:
1>		| &DerivedClass3_meta
1>		|  0
1> 0	| &DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vftable@DerivedClass2@:
1>		| -12
1> 0	| &thunk: this-=12; goto DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vbtable@DerivedClass1@:
1> 0	| -4
1> 1	| 24 (DerivedClass3d(DerivedClass1+4)Base)
1>DerivedClass3::$vbtable@DerivedClass2@:
1> 0	| -4
1> 1	| 12 (DerivedClass3d(DerivedClass2+4)Base)
1>DerivedClass3::$vftable@Base@:
1>		| -28
1> 0	| &Base::VirtualFunction
1>DerivedClass3::Derivedcommonfunction1 this adjustor: 0

1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base      28       4       4 0

如果全部都是虚继承（不自定义虚函数）

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};

class DerivedClass1 : virtual  public Base {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

class DerivedClass2 : virtual  public Base {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

class DerivedClass3 : virtual public DerivedClass1, virtual public DerivedClass2 {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass1	size(24):
1>		+---
1> 0	| {vfptr}
1> 4	| {vbptr}
1> 8	| c
1>		+---
1>		+--- (virtual base Base)
1>12	| {vfptr}
1>16	| a
1>20	| b
1>		+---
1>DerivedClass1::$vftable@DerivedClass1@:
1>		| &DerivedClass1_meta
1>		|  0
1> 0	| &DerivedClass1::Derivedcommonfunction1
1>DerivedClass1::$vbtable@:
1> 0	| -4
1> 1	| 8 (DerivedClass1d(DerivedClass1+4)Base)
1>DerivedClass1::$vftable@Base@:
1>		| -12
1> 0	| &Base::VirtualFunction
1>DerivedClass1::Derivedcommonfunction1 this adjustor: 0
1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base      12       4       4 0


1>class DerivedClass3	size(44):
1>		+---
1> 0	| {vbptr}
1> 4	| c
1>		+---
1>		+--- (virtual base Base)
1> 8	| {vfptr}
1>12	| a
1>16	| b
1>		+---
1>		+--- (virtual base DerivedClass1)
1>20	| {vfptr}
1>24	| {vbptr}
1>28	| c
1>		+---
1>		+--- (virtual base DerivedClass2)
1>32	| {vfptr}
1>36	| {vbptr}
1>40	| c
1>		+---
1>DerivedClass3::$vbtable@DerivedClass3@:
1> 0	| 0
1> 1	| 8 (DerivedClass3d(DerivedClass3+0)Base)
1> 2	| 20 (DerivedClass3d(DerivedClass3+0)DerivedClass1)
1> 3	| 32 (DerivedClass3d(DerivedClass3+0)DerivedClass2)
1>DerivedClass3::$vftable@Base@:
1>		| -8
1> 0	| &Base::VirtualFunction
1>DerivedClass3::$vftable@DerivedClass1@:
1>		| -20
1> 0	| &DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vbtable@DerivedClass1@:
1> 0	| -4
1> 1	| -16 (DerivedClass3d(DerivedClass1+4)Base)
1>DerivedClass3::$vftable@DerivedClass2@:
1>		| -32
1> 0	| &thunk: this-=12; goto DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vbtable@DerivedClass2@:
1> 0	| -4
1> 1	| -28 (DerivedClass3d(DerivedClass2+4)Base)
1>DerivedClass3::Derivedcommonfunction1 this adjustor: 20

1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base       8       0       4 0
1>   DerivedClass1      20       0       8 0
1>   DerivedClass2      32       0      12 0

如果都不是虚继承

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};

class DerivedClass1 :   public Base {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

class DerivedClass2 :   public Base {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

class DerivedClass3 :  public DerivedClass1,  public DerivedClass2 {
	int c;
public:
	virtual void Derivedcommonfunction1();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass1	size(16):
1>		+---
1> 0	| +--- (base class Base)
1> 0	| | {vfptr}
1> 4	| | a
1> 8	| | b
1>		| +---
1>12	| c
1>		+---
1>DerivedClass1::$vftable@:
1>		| &DerivedClass1_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1> 1	| &DerivedClass1::Derivedcommonfunction1
1>DerivedClass1::Derivedcommonfunction1 this adjustor: 0

1>class DerivedClass3	size(36):
1>		+---
1> 0	| +--- (base class DerivedClass1)
1> 0	| | +--- (base class Base)
1> 0	| | | {vfptr}
1> 4	| | | a
1> 8	| | | b
1>		| | +---
1>12	| | c
1>		| +---
1>16	| +--- (base class DerivedClass2)
1>16	| | +--- (base class Base)
1>16	| | | {vfptr}
1>20	| | | a
1>24	| | | b
1>		| | +---
1>28	| | c
1>		| +---
1>32	| c
1>		+---
1>DerivedClass3::$vftable@DerivedClass1@:
1>		| &DerivedClass3_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1> 1	| &DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vftable@DerivedClass2@:
1>		| -16
1> 0	| &Base::VirtualFunction
1> 1	| &thunk: this-=16; goto DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::Derivedcommonfunction1 this adjustor: 0

如果只有一个是虚继承

class Base {
	int a;
	int b;
public:
	virtual void VirtualFunction();
};

class DerivedClass1 :  virtual public Base {
	int c;
public:

	virtual void Derivedcommonfunction1();
};

class DerivedClass2 :   public Base {
	int c;
public:

	virtual void Derivedcommonfunction1();
};

class DerivedClass3 :  public DerivedClass1,  public DerivedClass2 {
	int c;
public:

	virtual void Derivedcommonfunction1();
};

1>class Base	size(12):
1>		+---
1> 0	| {vfptr}
1> 4	| a
1> 8	| b
1>		+---
1>Base::$vftable@:
1>		| &Base_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1>Base::VirtualFunction this adjustor: 0

1>class DerivedClass1	size(24):
1>		+---
1> 0	| {vfptr}
1> 4	| {vbptr}
1> 8	| c
1>		+---
1>		+--- (virtual base Base)
1>12	| {vfptr}
1>16	| a
1>20	| b
1>		+---
1>DerivedClass1::$vftable@DerivedClass1@:
1>		| &DerivedClass1_meta
1>		|  0
1> 0	| &DerivedClass1::Derivedcommonfunction1
1>DerivedClass1::$vbtable@:
1> 0	| -4
1> 1	| 8 (DerivedClass1d(DerivedClass1+4)Base)
1>DerivedClass1::$vftable@Base@:
1>		| -12
1> 0	| &Base::VirtualFunction
1>DerivedClass1::Derivedcommonfunction1 this adjustor: 0
1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base      12       4       4 0

1>class DerivedClass2	size(16):
1>		+---
1> 0	| +--- (base class Base)
1> 0	| | {vfptr}
1> 4	| | a
1> 8	| | b
1>		| +---
1>12	| c
1>		+---
1>DerivedClass2::$vftable@:
1>		| &DerivedClass2_meta
1>		|  0
1> 0	| &Base::VirtualFunction
1> 1	| &DerivedClass2::Derivedcommonfunction1
1>DerivedClass2::Derivedcommonfunction1 this adjustor: 0

1>class DerivedClass3	size(44):
1>		+---
1> 0	| +--- (base class DerivedClass1)
1> 0	| | {vfptr}
1> 4	| | {vbptr}
1> 8	| | c
1>		| +---
1>12	| +--- (base class DerivedClass2)
1>12	| | +--- (base class Base)
1>12	| | | {vfptr}
1>16	| | | a
1>20	| | | b
1>		| | +---
1>24	| | c
1>		| +---
1>28	| c
1>		+---
1>		+--- (virtual base Base)
1>32	| {vfptr}
1>36	| a
1>40	| b
1>		+---
1>DerivedClass3::$vftable@DerivedClass1@:
1>		| &DerivedClass3_meta
1>		|  0
1> 0	| &DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vftable@:
1>		| -12
1> 0	| &Base::VirtualFunction
1> 1	| &thunk: this-=12; goto DerivedClass3::Derivedcommonfunction1
1>DerivedClass3::$vbtable@:
1> 0	| -4
1> 1	| 28 (DerivedClass3d(DerivedClass1+4)Base)
1>DerivedClass3::$vftable@Base@:
1>		| -32
1> 0	| &Base::VirtualFunction
1>DerivedClass3::Derivedcommonfunction1 this adjustor: 0
1>vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
1>            Base      32       4       4 0
Huntersts
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++内存布局详解
beyond702的专栏
01-28 722
C++类中有两种成员变量，三种成员函数： 其中对象的内存布局中只包含非静态的成员变量，静态的成员变量是在全局数据区。 C++中类的继承类型，以及对应的类实例内存布局如下图： 1. 单继承 继承情况如下： 对应的对象内存布局： 2. 一般多继承（非菱形） 继承情况如下： 对应的对象内存布局： 3. 一般多继承（菱形） 类继承情况： 对应的对象内存布局...
C++空类及没有成员变量的类的大小实例分析
09-04
在内存布局中，为了优化访问速度，编译器通常会进行数据对齐。这意味着类的大小会被调整到某个特定的字节数的倍数，通常是编译器平台上的自然对齐边界，例如32位系统上通常是4字节。因此，即使`b`和`c`的总大小小于8...
C++变量在内存中的存储区域
louiswang2009的专栏
04-24 955
 01 #include 0203 #include 04 using namespace std;05 int a = 0; // Initialization Area of Overall06 char *p1; // Not Initialization Area of Overall0708 void main()09 {10 int b; // stack11 char s
C++类成员变量在内存中的排列顺序（布局）
weixin_43360707的博客
12-26 1864
首先明确几点： 1）c++标准要求，在同一个access section（private,protect,public）中members的排列只需要符合较晚出现的members在class object中较高的地址这一条即可。也就是说，members不一定要连续排列，什么东西可以插入到members中间呢，填充padding，以及虚函数表指针。 现在很多编译器把虚表指针放在class object的最前端，以前传统方式都是放在显式声明的members的最后喔。 class MyClass { public:
C/C++变量在内存中的分布
weixin_43417960的博客
10-31 541
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！                C/C++变量在内存中
c/c++里的 堆区 栈区 静态区 文字常量区 程序代码区
lcy9819的专栏
05-03 885
<br /> 一个由C/C++编译的程序占用的内存分为以下几个部分<br />　　1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 <br />       堆(heap)：由malloc,new等分配的空间的地址,地址由低向高增长（程序员释放）。<br />　　2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。 <br />       栈
详谈C++中虚基类在派生类中的内存布局
08-31
例如，在上述例子中，类`D`的对象`d`的内存布局可能包含vb_ptr（用于B和C的虚基类）以及各个成员变量。 在32位系统中，`sizeof(B)`和`sizeof(C)`可能比预期的大，因为它们各自包含了一个指向虚基类的指针。对于`D`...
C++ 内存对象布局
11-08
在C++中，对象的内存布局受到多种因素的影响，例如成员变量的类型、是否有虚函数等。接下来我们将详细探讨不同情况下的对象内存布局。 ##### 1. **空类** 空类是指没有任何成员变量的类。尽管此类没有任何成员，但...
C++中类对象的内存布局和占用空间
12-22
　* 非静态成员变量总合。 　* 加上编译器为了CPU计算，作出的数据对齐处理。 　* 加上为了支持虚函数，产生的额外负担。 　介绍完了理论知识后，再看看再找一个例子看看（注：一下所有结果都是在VC6.0 开发...
C++中类的内存空间大小（sizeof）分析
08-10
在C++编程中，了解类的内存空间大小是非常重要的，特别是涉及到性能优化和跨平台开发时。`sizeof`运算符用于...在编写代码时，可以利用`sizeof`来验证类的内存布局是否符合预期，这对于调试和性能调优是很有帮助的。
C++ 类内部的成员变量的内存分布
xjay_cc的专栏
11-09 1542
类的普通成员变量的内存分配 1 ：类的成员变量     内存在栈上 2 : 类的成员指针变量 指针变量在栈上   3 : 类的静态成员     内存在静态区 4 : 类的成员函数     普通成员函数,静态成员函数 都在代码区  5 : 类的引用变量     共享初始化时的变量的地址 (引用变量的内存实际还是在栈) 6 : 类的const变量    和常规变量一样 内存在栈 可
c++中类中成员在内存中的布局
bian_qing_quan11的博客
06-10 965
本篇博客来分析C++中类成员的内存布局情况。首先我们来分析下成员函数的内存布局，然后分析下类中成员变量的内存布局。 1. 类中成员函数布局 c++类中的成员函数包括有虚函数和普通成员函数。首先我们先来讨论下没有虚函数的类中成员函数是如何布局的。 （1）只含有普通成员函数的类 一个类也相当于一个作用域。对于不含虚函数的类而言，成员函数可以被看作是类作用域的全局函数，不在对象分配的空间里。也就
C++：对象及成员变量在内存中的存储分析
Magnum的博客
05-19 3230
类的成员变量并不能决定自身的存储空间位置。决定存储位置的是对象的创建方式。 即： 如果对象是函数内的非静态局部变量，则对象，对象的成员变量保存在栈区。 如果对象是全局变量，则对象，对象的成员变量保存在静态区。 如果对象是函数内的静态局部变量，则对象，对象的成员变量保存在静态区。 如果对象是new出来的，则对象，对象的成员变量保存在堆区。 下面是一个示例：当对象是new出来的时，其对象地址和成员变量、成员变量的成员变量、成员变量存储的数据都在堆区存储。 struct SQL{ SQL()
「C++ 类和对象篇 3」对象及其成员在内存中的存储
最新发布
look_outs的博客
12-03 1858
一、类在内存中的存储位置 二、对象在内存中的存储位置 三、成员函数的存储方法 四、成员变量在内存中的存储
C++中的成员变量内存布局
路过的熊的博客
10-29 137
C++中的成员变量内存布局
C++中：类数据成员的内存布局
Trageday的专栏
03-06 858
首先我们从一个有趣的问题引入：   class A  { }； 当我们运行 ：cout 为啥会是这样呢？其实在《深度探索C++对象模型》一本书中，有详细的解读，我在这只想说说自己的理解：首先class A 是一个类型，是用来实例化对象的，所以它就必须有具体的空间，使系统能按照它的格式分配内存。 如果  A   a； 当然sizeof（a）的结果也是1。这个是因为它是以一个对象存在的，我们必
C++类对象的内存布局
好记性不如写博客！
10-29 7342
1、C++类对象的内存布局 在C++的类对象中，有两种类的成员变量：static和非static，有三种成员函数：static、非static和virtual。那么，它们在C++的内存中是如何分布的呢？ C++程序的内存格局通常分为四个区：全局数据区(data area)，代码区(code area)，栈区(stack area)，堆区(heap area)(即自由存储区...
C++中，类继承的内存布局
zhangpinghao的专栏
11-29 842
对于普通的继承，不涉及虚拟继承时，比较简单。 如果继承多个父类则： 每个父类都有自己的虚表，子类虚成员函数加到第一个父类的虚函数列表后面 其它数据成员，按顺序依次放在各个父类的虚函数列表后面 以下内容，摘自网友 [0] Base1::_vptr->      [0] Derive::f()      [1] Base1::g()      [2] Base1
C/C++中变量的存储位置
线上幽灵
07-31 638
一个由 c/c++编译过的程序占用的内存分为如下几个部分 ： 栈区（stack） ：由编译器自动分配释放 ，存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。 堆区（heap） ：&amp;nbsp;一般由程序员分配释放， new, malloc之类的，若程序员不释放，程序结束时可能由OS回收 。 全局区（静态区）（static） ：存放全局变量、静态数据、常量。程序结束后由系统释放...
C++对象内存布局详解：成员变量与多种继承情况
本文将深入探讨C++对象的内存布局，特别是在不同继承模式下的细节。首先，我们将回顾C++对象可能受到的影响因素，包括成员变量、虚函数及其覆盖、单一继承、多重继承、重复继承以及虚拟继承。这些因素决定了对象内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值