简单研究C++ 对象内存布局

最新推荐文章于 2024-05-04 22:37:35 发布
最新推荐文章于 2024-05-04 22:37:35 发布
阅读量144 收藏
点赞数
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40871466/article/details/104329667
版权

关于C++对象布局 看了大佬的博客,大佬的博客过于久远格式比较清奇，我整理了，顺便改了程序能够在 64位机运行。

单一的一般继承

在这里插入图片描述
通俗的讲，一层层下去。

#include<iostream>
using namespace std;

class Parent
{
public:
    long iparent;//因为是64位机，所以改成了 long 
    
    Parent() : iparent(10) {}
    virtual void f() { cout << " Parent::f()" << endl; }
    virtual void g() { cout << " Parent::g()" << endl; }
    virtual void h() { cout << " Parent::h()" << endl; }
};

class Child : public Parent
{
public:
    long ichild;
    Child() : ichild(100) {}
    virtual void f() { cout << "Child::f()" << endl; }
    virtual void g_child() { cout << "Child::g_child()" << endl; }
    virtual void h_child() { cout << "Child::h_child()" << endl; }
};
class GrandChild : public Child
{
public:
    long igrandchild;
    GrandChild() : igrandchild(1000) {}
    virtual void f() { cout << "GrandChild::f()" << endl; }
    virtual void g_child() { cout << "GrandChild::g_child()" << endl; }
    virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }
};
typedef void (*Fun)(void);
int main()
{

    GrandChild gc;
    long **pVtab = (long **)&gc;
    Fun pFun;
    cout << "[0] GrandChild::_vptr->" << endl;
    for (int i = 0; (Fun)pVtab[0][i] != NULL; i += 2)
    {
        pFun = (Fun)pVtab[0][i];
        cout << "    [" << i << "] ";
        pFun();
    }
    printf("start offet:%llx\n", pVtab);
    cout << "[1] Parent.iparent = " << (long)((pVtab[1])) << endl;
    cout << "[2] Child.ichild = " << (long)(pVtab[2]) << endl;
    cout << "[3] GrandChild.igrandchild = " << (long)(pVtab[3]) << endl;
}

输出结果

[0] GrandChild::_vptr->
    [0] GrandChild::f()
    [2]  Parent::h()
    [4] Child::h_child()
start offet:7ffee4956f80
[1] Parent.iparent = 10
[2] Child.ichild = 100
[3] GrandChild.igrandchild = 1000

在这里插入图片描述

顺便我们用gdb 看一下。

GNU gdb (Debian 7.12-6) 7.12.0.20161007-git
list
40	    {
41	        pFun = (Fun)pVtab[0][i];
42	        cout << "    [" << i << "] ";
43	        pFun();
44	    }
45	    printf("start offet:%llx\n", pVtab);
46	    cout << "[1] Parent.iparent = " << (long)((pVtab[1])) << endl;
47	    cout << "[2] Child.ichild = " << (long)(pVtab[2]) << endl;
48	    cout << "[3] GrandChild.igrandchild = " << (long)(pVtab[3]) << endl;
49	}

p pVtab
$1 = (long **) 0x7fffffffcb90

x /10xg 0x7fffffffcb90
0x7fffffffcb90:	0x0000555555755ce0(你可以继续找下去可以找到具体函数地址)	0x000000000000000a(10)
0x7fffffffcba0:	0x0000000000000064(100)	0x00000000000003e8(1000)
0x7fffffffcbb0:	0x000000000000008e	0x000055555555509a
0x7fffffffcbc0:	0x00007fffffffcb90	0x0000000655554bf0
0x7fffffffcbd0:	0x00007fffffffccc0	0x0000000000000000

多重继承

在这里插入图片描述

#include<iostream>
using namespace std;
class Base1
{
public:
    long ibase1;
    Base1() : ibase1(0x10) {}
    virtual void f() { cout << "Base1::f()" << endl; }
    virtual void g() { cout << "Base1::g()" << endl; }
    virtual void h() { cout << "Base1::h()" << endl; }
};
class Base2
{
public:
    long ibase2;
    Base2() : ibase2(0x20) {}
    virtual void f() { cout << "Base2::f()" << endl; }
    virtual void g() { cout << "Base2::g()" << endl; }
    virtual void h() { cout << "Base2::h()" << endl; }
};
class Base3
{
public:
    long ibase3;
    Base3() : ibase3(0x30) {}
    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
{
public:
    long iderive;
    Derive() : iderive(0x100) {}
    virtual void f() { cout << "Derive::f()" << endl; }
    virtual void g1() { cout << "Derive::g1()" << endl; }
};
typedef void (*Fun)(void);
int main()
{
    Derive d;
    long **pVtab = (long **)&d;
    Fun pFun;
    cout<<hex;
    cout << "[0] Base1::_vptr->" << endl;
    pFun = (Fun)pVtab[0][0];
    cout << "     [0] ";
    pFun();
    pFun = (Fun)pVtab[0][1];
    cout << "     [1] ";
    pFun();
    pFun = (Fun)pVtab[0][2];
    cout << "     [2] ";
    pFun();
    pFun = (Fun)pVtab[0][3];
    cout << "     [3] ";
    pFun();
    pFun = (Fun)pVtab[0][4];
    cout << "     [4] ";
    cout << pFun << endl;
    cout << "[1] Base1.ibase1 = " << (long)(pVtab[1]) << endl;
    long s = sizeof(Base1) / 8;
    cout << "[" << s << "] Base2::_vptr->" << endl;
    pFun = (Fun)pVtab[s][0];
    cout << "     [0] ";
    pFun();
    cout << "     [1] ";
    pFun=(Fun)pVtab[s][1];
    pFun();
    pFun = (Fun)pVtab[s][2];
    cout << "     [2] ";
    pFun();
    pFun = (Fun)pVtab[s][3];
    cout << "     [3] ";
    cout << pFun << endl;
    cout << "[" << s + 1 << "] Base2.ibase2 = " << (long)(pVtab[s + 1]) << endl;
    s = s + sizeof(Base2) / 8;
    cout << "[" << s << "] Base3::_vptr->" << endl;
    pFun = (Fun)pVtab[s][0];
    cout << "     [0] ";
    pFun();
    pFun = (Fun)pVtab[s][1];
    cout << "     [1] ";
    pFun();
    pFun = (Fun)pVtab[s][2];
    cout << "     [2] ";
    pFun();
    pFun = (Fun)pVtab[s][3];
    cout << "     [3] ";
    cout << pFun << endl;
    s++;
    cout << "[" << s << "] Base3.ibase3 = " << (long)pVtab[s] << endl;
    s++;
    cout << "[" << s << "] Derive.iderive = " << (long)pVtab[s] << endl;
}

运行结果

[0] Base1::_vptr->
     [0] Derive::f()
     [1] Base1::g()
     [2] Base1::h()
     [3] Derive::g1()
     [4] 1//这个表示最后一个
[1] Base1.ibase1 = 10
[2] Base2::_vptr->
     [0] Derive::f()
     [1] Base2::g()
     [2] Base2::h()
     [3] 1
[3] Base2.ibase2 = 20
[4] Base3::_vptr->
     [0] Derive::f()
     [1] Base3::g()
     [2] Base3::h()
     [3] 0
[5] Base3.ibase3 = 30
[6] Derive.iderive = 100

用GDB看看

-exec p pVtab
$1 = (long **) 0x7fffffffcb80

-exec x /10xg 0x7fffffffcb80
0x7fffffffcb80:	0x0000555555756c50	0x0000000000000010
0x7fffffffcb90:	0x0000555555756c80	0x0000000000000020
0x7fffffffcba0:	0x0000555555756ca8	0x0000000000000030
0x7fffffffcbb0:	0x0000000000000100	0x0000000000000000
0x7fffffffcbc0:	0x000055555555583e	0x00007fffffffcb80

-exec x /10xg 0x0000555555756c50
0x555555756c50 <_ZTV6Derive+16>:	0x000055555555583e	0x00005555555555be
0x555555756c60 <_ZTV6Derive+32>:	0x00005555555555f6	0x0000555555555882
0x555555756c70 <_ZTV6Derive+48>:	0xfffffffffffffff0	0x0000555555756d38
0x555555756c80 <_ZTV6Derive+64>:	0x000055555555587b	0x000055555555568c
0x555555756c90 <_ZTV6Derive+80>:	0x00005555555556c4	0xffffffffffffffe0

-exec x /10xg 0x000055555555583e (不知道为啥其他查看其他几个虚表，和这个值不一样，但是也指向这个函数)
0x55555555583e <Derive::f()>:	0x10ec8348e5894855	0x57358d48f87d8948
0x55555555584e <Derive::f()+16>:	0x18083d8d48000001	0x48fffff453e80020
0x55555555585e <Derive::f()+32>:	0x201791058b48c289	0xe8d78948c6894800
0x55555555586e <Derive::f()+48>:	0x48c3c990fffff45e	0xef8348c3eb20ef83
0x55555555587e <_ZThn16_N6Derive1fEv+3>:	0xe589485590bdeb10	0xf87d894810ec8348

在这里插入图片描述

重复继承

在这里插入图片描述

#include <iostream>
using namespace std;
class B
{
public:
    long ib;
    char cb;

public:
    B() : ib(0), cb('B')
    {
    }

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

class B1 : public B
{
public:
    long ib1;
    char cb1;

public:
    B1() : ib1(11), cb1('1')
    {
    }
    virtual void
    f()
    {
        cout << "B1::f()" << endl;
    }
    virtual void f1() { cout << "B1::f1()" << endl; }
    virtual void Bf1() { cout << "B1::Bf1()" << endl; }
};

class B2 : public B
{
public:
    long ib2;
    char cb2;

public:
    B2() : ib2(12), cb2('2')
    {
    }
    virtual void
    f()
    {
        cout << "B2::f()" << endl;
    }
    virtual void f2() { cout << "B2::f2()" << endl; }
    virtual void Bf2() { cout << "B2::Bf2()" << endl; }
};

class D : public B1,
          public B2
{
public:
    long id;
    char cd;

public:
    D() : id(100), cd('D')
    {
    }
    virtual void
    f()
    {
        cout << "D::f()" << endl;
    }
    virtual void f1() { cout << "D::f1()" << endl; }
    virtual void f2() { cout << "D::f2()" << endl; }
    virtual void Df() { cout << "D::Df()" << endl; }
};

typedef void (*Fun)(void);
int main()
{
    long **pVtab = NULL;

    Fun pFun = NULL;

    D d;

    pVtab = (long **)&d;

    cout << "[0] D::B1::_vptr->" << endl;

    pFun = (Fun)pVtab[0][0];

    cout << "   [0] ";
    pFun();

    pFun = (Fun)pVtab[0][1];

    cout << "   [1] ";
    pFun();

    pFun = (Fun)pVtab[0][2];

    cout << "   [2] ";
    pFun();

    pFun = (Fun)pVtab[0][3];

    cout << "   [3] ";
    pFun();

    pFun = (Fun)pVtab[0][4];

    cout << "   [4] ";
    pFun();

    pFun = (Fun)pVtab[0][5];

    cout << "   [5] 0x" << pFun << endl;

    cout << "[1] B::ib = " << (long)pVtab[1] << endl;

    cout << "[2] B::cb = " << static_cast<char>((long)(pVtab[2])) << endl;

    cout << "[3] B1::ib1 = " << (long)pVtab[3] << endl;

    cout << "[4] B1::cb1 = " << (static_cast<char>((long)(pVtab[4]))) << endl;

    cout
        << "[5] D::B2::_vptr->" << endl;

    pFun = (Fun)pVtab[5][0];

    cout << "   [0] ";
    pFun();

    pFun = (Fun)pVtab[5][1];

    cout << "   [1] ";
    pFun();

    pFun = (Fun)pVtab[5][2];

    cout << "   [2] ";
    pFun();

    pFun = (Fun)pVtab[5][3];
    
    cout << "   [3] ";
    pFun();
    pFun = (Fun)pVtab[5][4];
    cout << "   [4] 0x" << pFun << endl;
    cout << "[6] B::ib = " << (long)pVtab[6] << endl;
    cout << "[7] B::cb = " << (static_cast<char>((long)pVtab[7])) << endl;
    cout << "[8] B2::ib2 = " << (long)pVtab[8] << endl;
    cout << "[9] B2::cb2 = " << (static_cast<char>((long)pVtab[9])) << endl;
    cout << "[10] D::id = " << (long)pVtab[10] << endl;
    cout << "[11] D::cd = " << (static_cast<char>((long)pVtab[11])) << endl;
}

输出结果

[0] D::B1::_vptr->
   [0] D::f()
   [1] B::Bf()
   [2] D::f1()
   [3] B1::Bf1()
   [4] D::f2()
   [5] 0x1
[1] B::ib = 0
[2] B::cb = B
[3] B1::ib1 = 11
[4] B1::cb1 = 1
[5] D::B2::_vptr->
   [0] D::f()
   [1] B::Bf()
   [2] D::f2()
   [3] B2::Bf2()
   [4] 0x0
[6] B::ib = 0
[7] B::cb = B
[8] B2::ib2 = 12
[9] B2::cb2 = 2
[10] D::id = 100
[11] D::cd = D

GDB调试

x /12x 0x7fffffffcb60
0x7fffffffcb60:	0x0000555555756c58	0x0000000000000123
0x7fffffffcb70:	0x0000555555756c55	0x0000000000000111
0x7fffffffcb80:	0x0000000000000011	0x0000555555756c98
0x7fffffffcb90:	0x0000000000000123	0x0000555555555555
0x7fffffffcba0:	0x0000000000000212	0x0000555555555a22
0x7fffffffcbb0:	0x0000000000000100	0x0000000000000033

虚拟继承

大佬偷懒了，那我们完了啊。

对于这个虚拟继承，和64位机好像有点不一样，我也不知道为啥。
如果有人看懂了回来私信我（留个言也行）。告诉我为啥。

我贴一个自己的实验。不保证正确性。

EW_DUST
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++对象的内存布局
giantpoplar的专栏
08-14 4013
本文介绍一个C++ struct/class在内存中的布局是什么样的，包括数据成员和方法成员，静态成员，非静态成员，虚拟成员在内存中的位置；本文不涉及（多）继承情况下对象内存布局的细节。
C++程序内存布局
Stone_Sky
03-09 1672
C++程序内存布局探讨（一） 刘昕 重庆大学软件学院 摘要： 本文探讨了C++程序内存布局的基础知识，对堆、栈、全局数据区和代码区的概念进行了简单介绍，并介绍了内存对齐和进程地址空间（虚拟内存）方面的知识。 今天一大早起来，收到外校的同学传给我的一道C++面试题，该公司做Windows平台下的C++开发。面试题有一道考C++程序内存布局，很具有代表性。 已知有这样一段代码：
C++类几种情况的内存布局
蜗牛想飞翔
10-17 3541
关于C++类内存布局的几种情况，需要多熟悉
C++ 对象的内存布局（上）
热门推荐
陈皓专栏　【空谷幽兰，心如皓月】
10-15 16万+
C++ 对象的内存布局(上) 陈皓http://blog.csdn.net/haoel  点击这里查看下篇＞＞＞前言 07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非
C/C++内存布局
Code_beeps的博客
04-27 4350
  下图是c/c++的进程的内存分布布局图，搞清楚内存布局对于理解一个程序是非常重要的。    一个程序运行起来，操作系统会给每个进程分配一个 4G 的程序地址空间，当然这都是虚拟地址空间，因为如果一个进程分 4G 的内存，那么就算有再多的内存也不够分。    这些虚拟地址空间中的内存分段都是什么意思呢？下面进行讲解： 一、首先进程地址空间的 1G 内核空间是给操作系统使用的，我们用户是没有操作...
C++界面库
_Witch__的专栏
09-03 6万+
开源C++界面库    1.RingSdk     Ringsdk是CSDN上一个前辈自己写的界面库，这个界面库很轻而易举实现QQ2009的界面效果。链接见    http://blog.csdn.net/ringphone/article/details/2911244   貌似Ringsdk和MFC无法进行交互，但是 RingSdk其中有很多的图形处理的代码都非常有参考价值。
C++ 内存对象布局
11-08
涉及各种情况下C++对象的sizeof大小，包括单一类对象，继承，重复继承 多继承 单一虚继承 等各种情况下的对象大小。对C++对象内存布局有清楚了解。
C++对象内存布局[归类].pdf
10-11
C++对象内存布局[归类].pdf
C++对象内存布局
05-01
介绍C++对象在内存中是怎样分布的，有助于深层学习C++。
C++中对象的内存分布
清新的世界
12-03 800
C++11类的内存分布： 目的:辅助了解 C++面向的对象的继承和多态。 实验平台:win10+vs2013 首先是创建一个win32的C++项目，右键->属性，C++选项,命令，添加一条命令: /d1reportAllClassLayout  查看所有相关类的内存分布; /d2reportSingleClassLayoutXXX(XXX为类名)
C++代码布局
ocfbnj的博客
10-09 401
C++代码布局 问题 一致的布局是很有用的，C++对代码的布局没有严格要求，这导致了许多C++代码都有不一样的布局风格，阅读起来很不方便。 在我们周围存在许多不同风格的代码布局，人们赞同或反对它。实际的项目可能包含了许多不同来源的代码，因此，统一代码的布局通常是不可能的。但是，在你不知道使用或不被要求使用某种布局时，使用一种统一的布局是明智的做法。 我们可以通过IDE或一些工具来格式化我们的代码，例如Visual Studio IDE和clang-format工具。 C++核心指南（C++之父参与编写）提供
C++ 对象内存布局
tq08g2z的专栏
05-29 1122
可能会对 C++ 对象的内存布局产生影响的因素： 对象的数据成员变量 对象的一般成员函数 对象的虚成员函数 对象继承 - 父类不包含虚函数 对象继承 - 父类包含虚函数 对象多继承 - 父类不包含虚函数 对象多继承 - 父类包含虚函数 对象虚继承 动态类型信息（这里不讨论） 通过汇编代码看虚函数调用过程 这些特性的实现常常因操作系统平台和编译器/ABI 而异，这里的分析主要基于 linux x86_64 平台上的 GCC 11.2.0/G++ 11.2.0 的行为进行。 一般 C++ 对象的内存布局
关于C++的对象布局
Hsuesh的博客
09-09 300
我们都知道C++多态是通过虚函数表来实现的，那具体是什么样的大家清楚吗？下面我们首先从了解什么是多态开始。 什么是多态 多态可以分为编译时多态和运行时多态。 编译时多态：基于模板和函数重载方式，在编译时就已经确定对象的行为，也称为静态绑定。 运行时多态：面向对象的一大特色，通过继承方式使得程序在运行时才会确定相应调用的方法，也称为动态绑定，它的实现主要是依赖于传说中的虚函数表。 如何查看对象的布局 在gcc中可以使用如下命令查看对象布局： g++ -fdump-class-hierarc..
【C++第三阶段】list容器&排序
还有很多需要学习，现在还很菜
04-29 672
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 275
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
c++中unrodered_map与unordered_set的基本使用
最新发布
山中一扶苏的博客
05-04 335
c++中unrodered_map与unordered_set的基本使用
手搓顺序表（C语言）
m0_62646213的博客
04-23 772
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 964
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
c++类对象在内存中的排列构造和析构函数
06-12
4. 如果类中存在非静态的成员对象，则在对象的内存布局中添加这些成员对象的内存空间。 在对象被创建时，会先调用构造函数来初始化对象的成员变量和其他相关内容。在对象被销毁时，会先调用析构函数来清理对象内部...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值