C++ 对象的内存布局

最新推荐文章于 2022-05-29 17:09:06 发布
最新推荐文章于 2022-05-29 17:09:06 发布
阅读量149 收藏 1
点赞数 1
分类专栏： C++ C++内存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38966867/article/details/117392893
版权

参考陈皓的三篇博客

C++ 虚函数表解析

C++ 对象的内存布局（上）

C++ 对象的内存布局（下）

[C语言面向对象]

虚函数表

实例对象的首地址保存着虚函数表指针

在这里插入图片描述

/*
 * @Description: 测试虚函数指针
 * @Version: 1.0
 * @Autor: hanhy
 */

#include <iostream>

using namespace std;
class Base {
public:
  virtual void f() { cout << "Base::f" << endl; }
  virtual void g() { cout << "Base::g" << endl; }
  virtual void h() { cout << "Base::h" << endl; }
};

int main() {

  cout << "=====================begin test============" << endl;
  Base base;

  cout << "sizeof(base)=" << sizeof(base) << endl; //保存一个虚函数表指针
  cout << "虚函数表地址（虚函数表指针）（16进制）：" << (long *)(&base) << endl;
  cout << "虚函数表中第一个函数地址（10进制）：" << *(long *)(&base) << endl;
  cout << "虚函数表中第一个函数地址（16进制）：" << (long *)*(long *)(&base)
       << endl;

  typedef void (*Fun)(void);

  Fun fun1=(Fun)*((long *)*(long *)(&base)+0);
  fun1();

  Fun fun2=(Fun)*((long *)*(long *)(&base)+1);
  fun2();

  Fun fun3=(Fun)*((long *)*(long *)(&base)+1);
  fun3();
}

在这里插入图片描述

一般继承（无虚函数覆盖）

在这里插入图片描述
在这里插入图片描述

/*
* @Description:一般继承 无覆盖重写虚函数
* @Version: 1.0
* @Autor: hanhy
*/
#include <iostream>

using namespace std;
class Base {
public:
 virtual void f() { cout << "Base::f" << endl; }
 virtual void g() { cout << "Base::g" << endl; }
 virtual void h() { cout << "Base::h" << endl; }
};

class Derive : public Base {};

int main() {

 cout << "=====================begin test============" << endl;
 Derive derive;

 cout << "sizeof(derive)=" << sizeof(derive) << endl; //保存一个虚函数表指针
 cout << "虚函数表地址（虚函数表指针）（16进制）：" << (long *)(&derive) << endl;
 cout << "虚函数表中第一个函数地址（10进制）：" << *(long *)(&derive) << endl;
 cout << "虚函数表中第一个函数地址（16进制）：" << (long *)*(long *)(&derive)
      << endl;

 typedef void (*Fun)();

 Fun fun1=(Fun)*((long *)*(long *)(&derive)+0);
 fun1();

 Fun fun2=(Fun)*((long *)*(long *)(&derive)+1);
 fun2();

 Fun fun3=(Fun)*((long *)*(long *)(&derive)+1);
 fun3();
}

在这里插入图片描述

一般继承（有虚函数覆盖）

在这里插入图片描述
在这里插入图片描述


/*
 * @Description: 一般继承有虚函数覆盖
 * @Version: 1.0
 * @Autor: hanhy
 */

#include <iostream>

using namespace std;
class Base {
public:
  virtual void f() { cout << "Base::f" << endl; }
  virtual void g() { cout << "Base::g" << endl; }
  virtual void h() { cout << "Base::h" << endl; }
};

class Derive : public Base {
  void f() override {cout << "Derive::f" << endl;}

};

int main() {

  cout << "=====================begin test============" << endl;
  Derive derive;

  cout << "sizeof(derive)=" << sizeof(derive) << endl; //保存一个虚函数表指针
  cout << "虚函数表地址（虚函数表指针）（16进制）：" << (long *)(&derive) << endl;
  cout << "虚函数表中第一个函数地址（10进制）：" << *(long *)(&derive) << endl;
  cout << "虚函数表中第一个函数地址（16进制）：" << (long *)*(long *)(&derive)
       << endl;

  typedef void (*Fun)();

  Fun fun1=(Fun)*((long *)*(long *)(&derive)+0);
  fun1();

  Fun fun2=(Fun)*((long *)*(long *)(&derive)+1);
  fun2();

  Fun fun3=(Fun)*((long *)*(long *)(&derive)+1);
  fun3();
}

在这里插入图片描述

多重继承（无虚函数覆盖）

在这里插入图片描述
在这里插入图片描述

/*
 * @Description:多重继承（无虚函数覆盖）
 * @Version: 1.0
 * @Autor: hanhy
 */

#include <iostream>

using namespace std;
class Base1 {
public:
  virtual void f() { cout << "Base1::f" << endl; }
  virtual void g() { cout << "Base1::g" << endl; }
  virtual void h() { cout << "Base1::h" << endl; }
};

class Base2 {
public:
  virtual void f() { cout << "Base2::f" << endl; }
  virtual void g() { cout << "Base2::g" << endl; }
  virtual void h() { cout << "Base2::h" << endl; }
};

class Base3 {
public:
  virtual void f() { cout << "Base3::f" << endl; }
  virtual void g() { cout << "Base3::g" << endl; }
  virtual void h() { cout << "Base3::h" << endl; }
};

class Derive : public Base1, public Base2, public Base3 {};

int main() {

  cout << "=====================begin test============" << endl;
  Derive derive;

  cout << "sizeof(derive)=" << sizeof(derive) << endl; //保存个三虚函数表指针
  cout << "虚函数表地址（虚函数表指针）（16进制）：" << (long *)(&derive)
       << endl;
  cout << "虚函数表中第一个函数地址（10进制）：" << *(long *)(&derive) << endl;
  cout << "虚函数表中第一个函数地址（16进制）：" << (long *)*(long *)(&derive)
       << endl;

  typedef void (*Fun)();

  cout << "------------------第一个虚函数表-------------------" << endl;
  Fun fun1 = (Fun) * ((long *)*(long *)(&derive) + 0);
  fun1();
  Fun fun2 = (Fun) * ((long *)*(long *)(&derive) + 1);
  fun2();
  Fun fun3 = (Fun) * ((long *)*(long *)(&derive) + 2);
  fun3();

  cout << "------------------第二个虚函数表-------------------" << endl;
  Fun fun4 = (Fun) * ((long *)*((long *)(&derive) + 1) + 0);
  fun4();
  Fun fun5 = (Fun) * ((long *)*((long *)(&derive) + 1) + 1);
  fun5();
  Fun fun6 = (Fun) * ((long *)*((long *)(&derive) + 1) + 2);
  fun6();

  cout << "------------------第二个虚函数表-------------------" << endl;
  Fun fun7 = (Fun) * ((long *)*((long *)(&derive) + 2) + 0);
  fun7();
  Fun fun8 = (Fun) * ((long *)*((long *)(&derive) + 2) + 1);
  fun8();
  Fun fun9 = (Fun) * ((long *)*((long *)(&derive) + 2) + 2);
  fun9();
}

在这里插入图片描述

多重继承（有虚函数覆盖）

在这里插入图片描述
在这里插入图片描述

/*
 * @Description:多重继承（有虚函数覆盖）
 * @Version: 1.0
 * @Autor: hanhy
 */

#include <iostream>

using namespace std;
class Base1 {
public:
  virtual void f() { cout << "Base1::f" << endl; }
  virtual void g() { cout << "Base1::g" << endl; }
  virtual void h() { cout << "Base1::h" << endl; }
};

class Base2 {
public:
  virtual void f() { cout << "Base2::f" << endl; }
  virtual void g() { cout << "Base2::g" << endl; }
  virtual void h() { cout << "Base2::h" << endl; }
};

class Base3 {
public:
  virtual void f() { cout << "Base3::f" << endl; }
  virtual void g() { cout << "Base3::g" << endl; }
  virtual void h() { cout << "Base3::h" << endl; }
};

class Derive : public Base1, public Base2, public Base3 {
  void f() override { cout << "Derive::f" << endl; }
};



int main() {

  cout << "=====================begin test============" << endl;
  Derive derive;

  cout << "sizeof(derive)=" << sizeof(derive) << endl; //保存个三虚函数表指针
  cout << "虚函数表地址（虚函数表指针）（16进制）：" << (long *)(&derive)
       << endl;
  cout << "虚函数表中第一个函数地址（10进制）：" << *(long *)(&derive) << endl;
  cout << "虚函数表中第一个函数地址（16进制）：" << (long *)*(long *)(&derive)
       << endl;

  typedef void (*Fun)();

  cout << "------------------第一个虚函数表-------------------" << endl;
  Fun fun1 = (Fun) * ((long *)*(long *)(&derive) + 0);
  fun1();
  Fun fun2 = (Fun) * ((long *)*(long *)(&derive) + 1);
  fun2();
  Fun fun3 = (Fun) * ((long *)*(long *)(&derive) + 2);
  fun3();

  cout << "------------------第二个虚函数表-------------------" << endl;
  Fun fun4 = (Fun) * ((long *)*((long *)(&derive) + 1) + 0);
  fun4();
  Fun fun5 = (Fun) * ((long *)*((long *)(&derive) + 1) + 1);
  fun5();
  Fun fun6 = (Fun) * ((long *)*((long *)(&derive) + 1) + 2);
  fun6();

  cout << "------------------第二个虚函数表-------------------" << endl;
  Fun fun7 = (Fun) * ((long *)*((long *)(&derive) + 2) + 0);
  fun7();
  Fun fun8 = (Fun) * ((long *)*((long *)(&derive) + 2) + 1);
  fun8();
  Fun fun9 = (Fun) * ((long *)*((long *)(&derive) + 2) + 2);
  fun9();
}

在这里插入图片描述

访问非public 虚函数

/*
 * @Description: 访问非public 虚函数
 * @Version: 1.0
 * @Autor: hanhy
 */

#include <iostream>

using namespace std;
class Base {
private:
  virtual void f() { cout << "Base::f" << endl; }
  virtual void g() { cout << "Base::g" << endl; }
  virtual void h() { cout << "Base::h" << endl; }
};

int main(){
  cout << "=====================begin test============" << endl;
  Base base;

  cout << "sizeof(base)=" << sizeof(base) << endl; //保存一个虚函数表指针
  cout << "虚函数表地址（虚函数表指针）（16进制）：" << (long *)(&base) << endl;
  cout << "虚函数表中第一个函数地址（10进制）：" << *(long *)(&base) << endl;
  cout << "虚函数表中第一个函数地址（16进制）：" << (long *)*(long *)(&base)
       << endl;

  typedef void (*Fun)(void);

  Fun fun1=(Fun)*((long *)*(long *)(&base)+0);
  fun1();
  Fun fun2=(Fun)*((long *)*(long *)(&base)+1);
  fun2();
  Fun fun3=(Fun)*((long *)*(long *)(&base)+1);
  fun3();
}

在这里插入图片描述

C++ 对象的内存布局上

在这里插入图片描述

单一的一般继承

在这里插入图片描述

海洋2416
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++对象内存布局
05-01
介绍C++对象在内存中是怎样分布的，有助于深层学习C++。
c++ 对象的内存布局
痞子龙3D编程
04-02 1010
前言07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非常简单的，主要是为了说明一些机理上的问题，也是为了图一些表达上方便和简单。不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家
C++ 对象的内存布局（下）
热门推荐
陈皓专栏　【空谷幽兰，心如皓月】
10-15 6万+
   C++ 对象的内存布局(下) 陈皓http://blog.csdn.net/haoel  ＜＜＜点击这里查看上篇  重复继承 下面我们再来看看，发生重复继承的情况。所谓重复继承，也就是某个基类被间接地重复继承了多次。 下图是一个继承图，我们重载了父类的f()函数。  其类继承的源代码如下所示。其中，每个类都有两个变量，一个是
c++对象内存的分配
weixin_34221112的博客
03-11 132
1 关于c++的对象 只要是用了class或者struct定义的，都是对象，不管有没有方法。不过，一般情况下，没有方法的对象用struct关键字来定义。 2 不用new关键字定义对象 要看这样的对象在内存中的位置，要看它所处的上下文。 如果是在函数中，那么这个对象的内存就是在该函数的栈上，其生命周期就是该函数的生命周期。 如果定义为另外一个类的成员变量，那么该对象的位置要看包含它的类在内...
C++ 内存对象布局
11-08
涉及各种情况下C++对象的sizeof大小，包括单一类对象，继承，重复继承 多继承 单一虚继承 等各种情况下的对象大小。对C++对象内存布局有清楚了解。
C++对象内存布局[归类].pdf
10-11
C++对象内存布局[归类].pdf
C++对象的内存布局
03-03
不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些内容没有涉及：1）...
C++类对象的内存布局
远行's Blog
01-06 885
一、内存对齐 C++的对象都会进行内存对齐，所谓内存对齐，指的是对象的地址和大小都会对齐到n的倍数上。比如按照4对齐，那么对象的地址会是4的倍数，对象的大小也是4的倍数。究其原因是，机器在内存对齐的地址上访问数据更快，可以一起取出数据；如果数据存在在不对齐的地址上，需要换成2次对齐地址上的取数据，再组合出原始数据；而且，部分机器根本没有取非对齐的数据。 1.1 默认对齐 class OrdinaryClassWithMemoryPack { public: int intA; short
c++对象内存布局
高性能架构探索
04-09 400
了解你所使用的编程语言究竟是如何实现的，对于C++程序员可能特别有意义。首先，它可以去除我们对于所使用语言的神秘感，使我们不至于对于编译器干的活感到完全不可思议；尤其重要的是，它使我们在Debug和使用语言高级特性的时候，有更多的把握。当需要提高代码效率的时候，这些知识也能够很好地帮助我们。 简单非多态的内存布局 classX{ intx; floatxx; public: X(){} ~X(){} voidprintInt()...
C++中对象的内存分布
清新的世界
12-03 800
C++11类的内存分布： 目的:辅助了解 C++面向的对象的继承和多态。 实验平台:win10+vs2013 首先是创建一个win32的C++项目，右键->属性，C++选项,命令，添加一条命令: /d1reportAllClassLayout  查看所有相关类的内存分布; /d2reportSingleClassLayoutXXX(XXX为类名)
C++ 对象内存布局
tq08g2z的专栏
05-29 1126
可能会对 C++ 对象的内存布局产生影响的因素： 对象的数据成员变量 对象的一般成员函数 对象的虚成员函数 对象继承 - 父类不包含虚函数 对象继承 - 父类包含虚函数 对象多继承 - 父类不包含虚函数 对象多继承 - 父类包含虚函数 对象虚继承 动态类型信息（这里不讨论） 通过汇编代码看虚函数调用过程 这些特性的实现常常因操作系统平台和编译器/ABI 而异，这里的分析主要基于 linux x86_64 平台上的 GCC 11.2.0/G++ 11.2.0 的行为进行。 一般 C++ 对象的内存布局
C++中对象的内存布局（一）
zhuoya_的博客
04-22 1876
在上篇文章《戳我》中，简单说了继承的三种分类：单继承、多重继承、重复继承。一般的如果没有虚函数，那对象的内存布局就如我们看到的一样，定义了几个变量根据字节对齐就能算出其在内存中所占字节大小。但是有了虚函数，就不同了，因为有了虚函数就意味着存在虚函数指针，那指针我们知道是占四个字节（32位）的，所以从本篇文章开始来分析存在虚函数时对象的内存布局是怎么样的？（版本是Visual Studio2012）...
C++对象 内存分布
小猪爱拱地
12-27 955
代码如下： class T { public : T(); virtual int f(void); private : int d; }; T::T(void) { d = 0x12345678; } int T::f(void) { return 12; } void x(T& t) {
C++ - 对象的内存布局
weixin_49303682的博客
08-14 259
1.class与struct -> class是一种特殊的struct。 -> 在内存中class依旧可以看作变量的集合。 -> class与struct遵循相同的内存对齐规则。 -> class中的成员函数与成员变量是分开存放的。 -> 每个对象有独立的成员变量。 -> 所有对象共享类中的成员函数。 代码示例：对象的内存分布 #include <iostream> #include <string> using namesp
深度探索c++对象模型
最新发布
05-27
C++对象模型涉及到了内存布局、虚函数表、多重继承等方面的知识，是C++程序员必须掌握的一门课程。 在C++对象模型中，每个对象都包含了一个指向虚函数表的指针，虚函数表包含了所有虚函数的地址。当对象调用虚函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海洋2416

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值