一起探索C++类内存分布

最新推荐文章于 2024-05-19 23:08:48 发布
最新推荐文章于 2024-05-19 23:08:48 发布
阅读量212 收藏 1
点赞数 1
分类专栏： C\C++ 文章标签： c++ 指针 多态 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/travelerwz/article/details/113762247
版权
本文深入探讨了C++类的内存布局，包括普通类、含有继承、虚函数、虚拟继承以及菱形继承的情况。通过VS2015调试，展示了虚表、成员变量的分布以及内存调整。总结了虚继承如何减少基类重复，但增加虚表指针负担。
摘要由CSDN通过智能技术生成

一起探索C++类内存分布

C++ 类中内存分布具体是怎么样，尤其是C++中含有继承、虚函数、虚拟继承以及菱形继承等等情况下。

由于在linux下没有windows下显示直观，我们采用vs2015进行调试。

  • 部署环境

    我们在 属性->C/C++ ->命令行 -> /d1 reportSingleClassLayoutXXX ,XXX表示类名；

在这里插入图片描述

  • 单个基础类

    class Base
{
private:
	int a;
	int b;
public:
	void test();
};

    内存分布：

    class Base size(8):
  	+-- -
   0 | a
   4 | b
  	+-- -

    总结：我们发现普通类的内存分布是根据声明的顺序进行的,成员函数不占用内存。

  • 基础类+继承类

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

class Divide :public Base
{
public:
	void run();
private:
	int c;
	int d;
};

    内存分布：

    class Divide	size(16) :
  	+-- -
   0 | +-- - (base class Base)
   0 | | a
   4 | | b
 | +-- -
   8 | c
  12 | d
  	+-- -

    总结：根据内存分布，我们发现普通继承类，内存分布也是按照声明的顺序进行的，成员函数不占用内存；类的顺序是先基类，后子类。

  • 含有虚函数的基类

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

    内存分布：

    class Base	size(12) :
  	+-- -
   0 | {vfptr}
   4 | a
   8 | b
  	+-- -

  Base::$vftable@:
 | &Base_meta
 | 0
   0 | &Base::run

    总结：带有虚函数的内存分布分为两部分，一部分是内存分布，一部分是虚表；我们从最上面发现，vfptr是放在了内存开始处，然后才是成员变量；虚函数run前面表示这个虚函数的序号为0。

  • 含有虚函数的基类+继承子类

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

class Divide :public Base
{
public:
	void DivideFun();
	virtual void run();
private:
	int c;
	int d;
};

    内存分布：

    class Divide size(20) :
  	+-- -
   0 | +-- - (base class Base)
   0 | | {vfptr}
   4 | | a
   8 | | b
 | +-- -
  12 | c
  16 | d
  	+-- -

  Divide::$vftable@:
 | &Divide_meta
 | 0
   0 | &Divide::run

    总结：我们发现继承类，虚表只有一个，还是在内存开始处，内存排布顺序与普通继承类是一致的；

  • 含有虚函数的基类+继承子类（多增加一个虚函数）

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

class Divide :public Base
{
public:
	void DivideFun();
	virtual void run();
	virtual void DivideRun();
private:
	int c;
	int d;
};

    内存分布：

    class Divide	size(20) :
  	+-- -
   0 | +-- - (base class Base)
   0 | | {vfptr}
   4 | | a
   8 | | b
 | +-- -
  12 | c
  16 | d
  	+-- -

  Divide::$vftable@:
 | &Divide_meta
 | 0
   0 | &Divide::run
   1 | &Divide::DivideRun

    总结：虚表还是继承于基类，在虚表部分多了DivideRun序号为1的虚函数；

  • 多重继承

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

class Divide1 :public Base
{
public:
	virtual void run();
private:
	int c;
};

class Divide2 :public Base
{
public:
	virtual void run();
private:
	int d;
};

class Divide :public Divide1, Divide2
{
public:
	virtual void run();
private:
	int d;
};

    内存分布：

    class Divide1	size(16) :
  	+-- -
   0 | +-- - (base class Base)
   0 | | {vfptr}
 4 | | a
 8 | | b
| +-- -
 12 | c
 	+-- -

 Divide1::$vftable@:
| &Divide1_meta
| 0
  0 | &Divide1::run

 Divide1::run this adjustor: 0

 class Divide2	size(16) :
  +-- -
   0 | +-- - (base class Base)
   0 | | {vfptr}
  4 | | a
  8 | | b
| +-- -
 12 | d
 	+-- -

 Divide2::$vftable@:
| &Divide2_meta
| 0
  0 | &Divide2::run

 Divide2::run this adjustor: 0

 class Divide	size(36) :
  +-- -
   0 | +-- - (base class Divide1)
   0 | | +-- - (base class Base)
   0 | | | {vfptr}
 4 | | | a
 8 | | | b
| | +-- -
 12 | | c
| +-- -
  | +-- - (base class Divide2)
  | | +-- - (base class Base)
  | | | {vfptr}
  | | | a
  | | | b
| | +-- -
  | | d
| +-- -
  | d
 	+-- -

 Divide::$vftable@Divide1@:
| &Divide_meta
| 0
  0 | &Divide::run

 Divide::$vftable@Divide2@:
| -16
  0 | &thunk: this -= 16; goto Divide::run

 Divide::run this adjustor: 0

    总结：主要看最后一个Divide类，内存排列顺序先是Divide1，后是Divide2，在Divide1和Divide2中各有一份虚表；

  • 虚拟继承（菱形继承）

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

class Divide1 :virtual public Base
{
public:
	virtual void run();
private:
	int c;
};

class Divide2 :virtual public Base
{
public:
	virtual void run();
private:
	int d;
};

class Divide :public Divide1, Divide2
{
public:
	virtual void run();
private:
	int d;
};

    内存分布：

    class Divide1	size(20) :
	  	+-- -
	   0 | {vbptr}
   4 | c
  	+-- -
  	+-- - (virtual base Base)
   8 | {vfptr}
  12 | a
  16 | b
  	+-- -

  Divide1::$vbtable@:
   0 | 0
   1 | 8 (Divide1d(Divide1 + 0)Base)

  Divide1::$vftable@:
 | -8
   0 | &Divide1::run

  Divide1::run this adjustor: 8
  vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
              Base       8       0       4 0

  class Divide2	size(20) :
  	+-- -
   0 | {vbptr}
   4 | d
  	+-- -
  	+-- - (virtual base Base)
   8 | {vfptr}
  12 | a
  16 | b
  	+-- -

  Divide2::$vbtable@:
   0 | 0
   1 | 8 (Divide2d(Divide2 + 0)Base)

  Divide2::$vftable@:
 | -8
   0 | &Divide2::run

  Divide2::run this adjustor: 8
  vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
              Base       8       0       4 0

  class Divide	size(32) :
  	+-- -
   0 | +-- - (base class Divide1)
   0 | | {vbptr}
   4 | | c
 | +-- -
   8 | +-- - (base class Divide2)
   8 | | {vbptr}
  12 | | d
 | +-- -
  16 | d
  	+-- -
  	+-- - (virtual base Base)
  20 | {vfptr}
  24 | a
  28 | b
  	+-- -

  Divide::$vbtable@Divide1@:
   0 | 0
   1 | 20 (Divided(Divide1 + 0)Base)

  Divide::$vbtable@Divide2@:
   0 | 0
   1 | 12 (Divided(Divide2 + 0)Base)

  Divide::$vftable@:
 | -20
   0 | &Divide::run

    总结：通过内存分布可知，Divide1和Divide2都是两个虚表，Divide中却是成了3个虚表，只有一份base；所以说：虚继承的作用是减少了对基类的重复，代价是增加了虚表指针的负担（增加了更多的需指针）

ase Base)
20 | {vfptr}
24 | a
28 | b
±- -

Divide::$vbtable@Divide1@:
 0 | 0
 1 | 20 (Divided(Divide1 + 0)Base)

Divide::$vbtable@Divide2@:
 0 | 0
 1 | 12 (Divided(Divide2 + 0)Base)

Divide::$vftable@:

| -20
0 | &Divide::run


总结：通过内存分布可知，`Divide1`和`Divide2`都是两个虚表，Divide中却是成了3个虚表，只有一份base；所以说：**虚继承的作用是减少了对基类的重复，代价是增加了虚表指针的负担（增加了更多的需指针）**

**********
后台服务器开发
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深度探索C++对象模型笔记
C语言与CPP编程的博客
11-18 1367
一、关于对象C 语言是程序性的，语言本身并没有支持数据和函数之间的关联性C++ 中可能采取抽象数据类型，或者是多层次的类结构完成C++ 的封装并没有增加多少成本，每一个成员函数虽然在cla...
C++内存分配的对齐规则
03-18
C++里的内存资源对齐规则，从更深刻的角度向大家展示了指针的密码
一个很不错的网站
百里鹤的专栏
05-19 723
http://www.uml.org.cn 内容很是全面，抄袭一篇文章 一、一个经过编译的C/C++的程序占用的内存分成以下几个部分：1、栈区（stack）：由编译器自动分配和释放 ，存放函数的参数值、局部变量的值等，甚至函数的调用过程都是用栈来完成。其操作方式类似于数据结构中的栈。2、堆区（heap） ：一般由程序员手动申请以及释放， 若程序员不释放，程序结束时可能由OS
C/C++ Memory Layout
weixin_33698043的博客
03-07 165
为什么需要知道C/C++的内存布局和在哪可以可以找到想要的数据？知道内存布局对调试程序非常有帮助，可以知道程序执行时，到底做了什么，有助于写出干净的代码。本文的主要内容如下： 源文件转换为可执行文件 可执行程序组成及内存布局 数据存储类别 一个实例 总结 源文件转换为可执行文件 源文件经过以下几步生成可执行文件： 1、预处理（preprocessor）...
内存划分
09-23 1008
在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。    栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。    堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
C++:内存分布
weixin_42362528的博客
04-25 1598
C++中的内存分布
(C++)深度探索C++对象模型_C++_
10-03
在C++编程语言中，对象模型是理解和利用其特性至关重要的基础。C++对象模型描述了C++程序在内存中的表示方式，包括类、...阅读《(C++)深度探索C++对象模型》这本书将帮助你全面掌握这些知识，并提升你的C++编程技能。
C++堆内存分配
unclerunning的博客
03-30 5350
C++堆内存分配C堆内存分配 抽象与分层 如何扩展有效堆内存 brk和sbrk系统调用 如何维护有效堆内存 operator new抽象与分层​ c和c++的内存服务模型与计算机网络里面的协议分层模型有点类似。计算机网络协议大体分为５层：应用层、传输层、网络层、数据链接层和物理层。其中，上层仅仅只需在下层所提供的服务之上构建自己的服务，而不用关心它的下下层所提供的服务。例如，http应用要完成相
C++ 类中数据成员分布详解
weixin_39640298的博客
12-22 5307
概述 我们都知道类中包含着数据成员，但是数据成员在内存中是怎样分布的呢？继承之后数据又是怎样布局的呢？下面对这些问题进行整理。类的空间分布是编译器编译的结果，不同的编译器有可能会不一样，但是原理是一样的。 1、空类 我们定义了一个空类，然后对空类进行sizeof计算，如下： class myclass { }； cout << sizeof myclass &a
C++ 内存分布
RandyOliver's House
05-08 188
一个程序的section，组成。在C++中，内存分成5个区：堆、栈、自由存储区、全局/静态存储区和代码段。，存储局部变量函数参数值。函数执行结束时这些存储单元自动被释放。栈从高地址向低地址增长。是一块连续的空间。，就是由malloc分配的内存块，一个malloc就必须要对应一个free。堆从低地址向高地址增长。，由new等分配的内存块，通过delete来释放空间，全局变量和静态变量被分配到同一块内存中，存放的是可执行的代码。只读，代码段的头部还会包含一些只读的常数变量。
C/C++中内存区域划分大总结
歌行梅村的专栏
10-23 1350
C/C++中内存区域划分大总结 2011-04-13 16:50 中国IT实验室   程序由代码和数据组成，其中代码存储在代码区中，数据根据类型的不同存储在不同的区域中。本文分别介绍了C和C++中内存区域的划分。 AD：2013云计算架构师峰会精彩课程曝光 C++作为一款C语言的升级版本，具有非常强大的功能。它不但能够支持各种
c++内存分布
最新发布
weixin_60668256的博客
05-19 807
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。6.申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的。但是如果碰上异常时，就算注意释放了，还是可能会出问题。
C++内存分布
qq_65112813的博客
05-05 918
图中描绘得很清楚，调用operator new申请空间在申请的空间上调用构造函数，完成对象的初始化。
C++入门基础(八) 内存分布一览
dream_i_success的博客
03-17 128
  内存，一个看不见也摸不着的东西，我们每天都在接触它但是却很少真正去了解过它。在我们学习程序语言时，是不是经常会接触内存泄漏、动态开辟、地址等等的词语？是的，它们均与我们所说的内存有着千丝万缕的关系，今天，我们便走进内存，简单了解其基本的构造。 内存的六大分区   我们常说的内存分区一般有两种分法，其一是常说的五大分区，分别是堆、栈、自由存储区、全局/静态存储区以及常量存储区；而另一种我们说是六大段，其分别是内核空间、栈、内存映射区、堆、数据段、代码段。 内核空间   通常，计算机会在默认情况在将高地址的
类的内存分布
u013357189的博客
10-24 248
类的大小计算的时候，只包括： 1 类的非静态成员数据的类型大小之和． 2 如果有虚函数的话，还要加上指向虚函数的指针（vptr）大小 3 边缘调整后的大小 4 与类中的构造函数，析构函数以及其他的成员函数无关． 这些成员函数实际上都是些全局函数，最后都会由this指针进行绑定。所以，他们不会占用类的空间C++类内存分布 转载的http://www.cnblogs.com/jerry1
C++教程：探索指针与内存管理
数据封装是面向对象编程的核心概念之一，它涉及到将数据和操作这些数据的方法绑定在一起，形成一个独立的实体——类。在C++中，数据封装通过访问修饰符（public、private和protected）实现，它可以保护数据不受未经...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值