C++对象成员函数存储示例

最新推荐文章于 2022-04-30 00:32:05 发布
最新推荐文章于 2022-04-30 00:32:05 发布
阅读量289 收藏
点赞数
分类专栏： 深度探索C++对象模型 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Spring_24/article/details/105900322
版权

目录

本文主要以示例说明C++对象成员函数的存储布局，有关理论知识，请参考Fuction语意学。

一、成员函数

1.1、无继承

#include <iostream>
using namespace std;

class X
{
public:
    int a = 0;
    int b = 1;
    virtual void f1() { cout << "X::f1()" << endl; }
    virtual void f2() { cout << "X::f2()" << endl; }
    virtual void f3() { cout << "X::f3()" << endl; }
};

int main()
{
    X x;
    cout << "X:" << endl;
    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "vptr address: " << (&x) << endl;
    cout << "x.a address: " << &x.a << endl;
    cout << "x.b address: " << &x.b << endl;

    using f = void (*)();
    f fun = reinterpret_cast<f>(*(int*)(&x));
    f t1 = reinterpret_cast<f>(((int*)fun)[0]);
    f t2 = reinterpret_cast<f>(((int*)fun)[1]);
    f t3 = reinterpret_cast<f>(((int*)fun)[2]);
    t1();
    t2();
    t3();

    return 0;
}

运行时的内存结果如下：
在这里插入图片描述
程序运行结果如下：
在这里插入图片描述
x的内存布局如下所示：
在这里插入图片描述
在这里插入图片描述

1.2、单一继承

#include <iostream>
using namespace std;

class X
{
public:
    int a = 0;
    int b = 1;
    virtual void f1() { cout << "X::f1()" << endl; }
    virtual void f2() { cout << "X::f2()" << endl; }
    virtual void f3() { cout << "X::f3()" << endl; }
};

class Y : public X
{
};

class Z : public X
{
    void f1() { cout << "Z::f1()" << endl; }
    void f2() { cout << "Z::f2()" << endl; }
};

int main()
{
    X x;
    cout << "X:" << endl;
    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "vptr address: " << (&x) << endl;
    cout << "x.a address: " << &x.a << endl;
    cout << "x.b address: " << &x.b << endl;

    Y y;
    cout << "Y:" << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;
    cout << "vptr address: " << (&y) << endl;
    cout << "y.a address: " << &y.a << endl;
    cout << "y.b address: " << &y.b << endl;

    Z z;
    cout << "Z:" << endl;
    cout << "sizeof(Z) = " << sizeof(Z) << endl;
    cout << "vptr address: " << (&z) << endl;
    cout << "z.a address: " << &z.a << endl;
    cout << "z.b address: " << &z.b << endl;


    using f = void (*)();
    f funx = reinterpret_cast<f>(*(int*)(&x));

    f x1 = reinterpret_cast<f>(((int*)funx)[0]);
    f x2 = reinterpret_cast<f>(((int*)funx)[1]);
    f x3 = reinterpret_cast<f>(((int*)funx)[2]);
    x1();
    x2();
    x3();

    f funy = reinterpret_cast<f>(*(int*)(&y));

    f y1 = reinterpret_cast<f>(((int*)funy)[0]);
    f y2 = reinterpret_cast<f>(((int*)funy)[1]);
    f y3 = reinterpret_cast<f>(((int*)funy)[2]);
    y1();
    y2();
    y3();

    f funz = reinterpret_cast<f>(*(int*)(&z));

    f z1 = reinterpret_cast<f>(((int*)funz)[0]);
    f z2 = reinterpret_cast<f>(((int*)funz)[1]);
    f z3 = reinterpret_cast<f>(((int*)funz)[2]);
    z1();
    z2();
    z3();

    return 0;
}

其中，Y没有覆盖X的虚函数，因此Y的对象中虚函数的地址与X中虚函数的地址相同，都指向X中的虚函数；Z中覆盖了f1()、f2()，没有覆盖f3()，因此，Z的对象中f1()和f2()的地址与X中的f1()和f2()的地址不相同，分别指向X和Z中的虚函数；而f3()的地址相同，都指向X中的虚函数。

运行时的内存结果如下：
在这里插入图片描述
程序运行结果如下：
在这里插入图片描述
x、y、z的内存布局如下：
在这里插入图片描述

在这里插入图片描述

1.3、多重继承

#include <iostream>
using namespace std;

class X
{
public:
    int a = 0;
    int b = 1;
    virtual void fx1() { cout << "X::fx1()" << endl; }
    virtual void fx2() { cout << "X::fx2()" << endl; }
};

class Y
{
public:
    virtual void fy1() { cout << "Y::fy1()" << endl; }
    virtual void fy2() { cout << "Y::fy2()" << endl; }
};

class M : public X, public Y
{
    void fx1() { cout << "M::fx1()" << endl; }
    void fy1() { cout << "M::fy1()" << endl; }
};

int main()
{
    X x;
    cout << "X:" << endl;
    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "vptr address: " << (&x) << endl;
    cout << "x.a address: " << &x.a << endl;
    cout << "x.b address: " << &x.b << endl;

    Y y;
    cout << "Y:" << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;
    cout << "vptr address: " << (&y) << endl;

    M m;
    cout << "M:" << endl;
    cout << "sizeof(M) = " << sizeof(M) << endl;
    cout << "vptr address: " << (&m) << endl;
    cout << "m.a address: " << &m.a << endl;
    cout << "m.b address: " << &m.b << endl;

    using f = void (*)();
    f funx = reinterpret_cast<f>(*(int*)(&x));
    f x1 = reinterpret_cast<f>(((int*)funx)[0]);
    f x2 = reinterpret_cast<f>(((int*)funx)[1]);
    x1();
    x2();

    f funy = reinterpret_cast<f>(*(int*)(&y));
    f y1 = reinterpret_cast<f>(((int*)funy)[0]);
    f y2 = reinterpret_cast<f>(((int*)funy)[1]);
    y1();
    y2();

    f funmx = reinterpret_cast<f>(*(int*)(&m));
    f mx1 = reinterpret_cast<f>(((int*)funmx)[0]);
    f mx2 = reinterpret_cast<f>(((int*)funmx)[1]);
    mx1();
    mx2();

    f funmy = reinterpret_cast<f>(((int*)(&m))[3]);
    f my1 = reinterpret_cast<f>(((int*)funmy)[0]);
    f my2 = reinterpret_cast<f>(((int*)funmy)[1]);
    my1();
    my2();

    return 0;
}

其中，M没有覆盖X中的fx2()，因此M中虚函数fx2()的地址与X中虚函数fx2()的地址相同，都指向X中的虚函数fx2()；M覆盖了X中的fx1()，因此M中虚函数fx1()的地址与X中虚函数fx1()的地址不相同，分别指向X和M中的虚函数。M和Y的关系与之类似。

运行时的内存结果如下：
在这里插入图片描述
程序运行结果如下：
在这里插入图片描述
x、y、m的内存布局如下：
在这里插入图片描述

1.4、虚继承

1.4.1、单一虚继承

#include <iostream>
using namespace std;

class X
{
public:
    int a = 0;
    int b = 1;
    virtual void fx1() { cout << "X::fx1()" << endl; }
};

class Y :virtual public X
{
public:
    virtual void fy1() { cout << "Y::fy1()" << endl; }
};

class Z :virtual public X
{
public:
    virtual void fz1() { cout << "Z::fz1()" << endl; }
    void fx1() { cout << "Z::fx1()" << endl; }
};

int main()
{
    X x;
    cout << "X:" << endl;
    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "vptr address: " << (&x) << endl;
    cout << "x.a address: " << &x.a << endl;
    cout << "x.b address: " << &x.b << endl;

    Y y;
    cout << "Y:" << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;
    cout << "vptr address: " << (&y) << endl;
    cout << "y.a address: " << &y.a << endl;
    cout << "y.b address: " << &y.b << endl;

    Z z;
    cout << "Z:" << endl;
    cout << "sizeof(Z) = " << sizeof(Z) << endl;
    cout << "vptr address: " << (&z) << endl;
    cout << "z.a address: " << &z.a << endl;
    cout << "z.b address: " << &z.b << endl;

    using f = void (*)();
    f funx = reinterpret_cast<f>(*(int*)(&x));
    f x1 = reinterpret_cast<f>(((int*)funx)[0]);
    x1();

    f funy = reinterpret_cast<f>(*(int*)(&y));
    f y1 = reinterpret_cast<f>(((int*)funy)[0]);
    y1();

    f funyx = reinterpret_cast<f>(*((int*)(&y) + 2));
    f yx1 = reinterpret_cast<f>(((int*)funyx)[0]);
    yx1();

    f funz = reinterpret_cast<f>(*(int*)(&z));
    f z1 = reinterpret_cast<f>(((int*)funz)[0]);
    z1();

    f funzx = reinterpret_cast<f>(*((int*)(&z) + 2));
    f zx1 = reinterpret_cast<f>(((int*)funzx)[0]);
    zx1();

    return 0;
}

其中，Y通过虚继承的方式继承于X，在Y的对象中，首先存放的是Y的虚函数地址，接下来存放的是虚基类表指针，然后是Y的数据成员，最后是X的子对象。在虚基类表中存放的是偏移值，第一个是虚基类表指针距离子对象Y的偏移，第二个是距离虚基类子对象X的偏移。在Y中没有覆盖X的虚函数，因此Y中虚函数fx1()的地址与X中虚函数fx1()的地址相同，都指向X中的虚函数fx1()；Z覆盖了X中的fx1()，因此Z中虚函数fx1()的地址与X中虚函数fx1()的地址不相同，分别指向Z和X中的虚函数fx1()。

运行时的内存结果如下：
在这里插入图片描述
程序运行结果如下：
在这里插入图片描述

x、y、z的内存布局如下：
在这里插入图片描述

在这里插入图片描述

1.4.2、多重虚继承

#include <iostream>
using namespace std;

class X
{
public:
    int a = 0;
    int b = 1;
    virtual void fx1() { cout << "X::fx1()" << endl; }
};

class Y :virtual public X
{
public:
    int c = 2;
    virtual void fy1() { cout << "Y::fy1()" << endl; }
};

class Z :virtual public X
{
public:
    virtual void fz1() { cout << "Z::fz1()" << endl; }
};

class M :public Y, public Z
{
public:
    int d = 3;
    virtual void fm1() { cout << "M::fm1()" << endl; }
    void fx1() { cout << "M::fx1()" << endl; }
};

int main()
{
    X x;
    cout << "X:" << endl;
    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "vptr address: " << (&x) << endl;
    cout << "x.a address: " << &x.a << endl;
    cout << "x.b address: " << &x.b << endl;

    Y y;
    cout << "Y:" << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;
    cout << "vptr address: " << (&y) << endl;
    cout << "y.a address: " << &y.a << endl;
    cout << "y.b address: " << &y.b << endl;
    cout << "y.c address: " << &y.c << endl;

    Z z;
    cout << "Z:" << endl;
    cout << "sizeof(Z) = " << sizeof(Z) << endl;
    cout << "vptr address: " << (&z) << endl;
    cout << "z.a address: " << &z.a << endl;
    cout << "z.b address: " << &z.b << endl;

    M m;
    cout << "M:" << endl;
    cout << "sizeof(M) = " << sizeof(M) << endl;
    cout << "vptr address: " << (&m) << endl;
    cout << "m.a address: " << &m.a << endl;
    cout << "m.b address: " << &m.b << endl;
    cout << "m.c address: " << &m.c << endl;
    cout << "m.d address: " << &m.d << endl;

    using f = void (*)();
    f funx = reinterpret_cast<f>(*(int*)(&x));
    f x1 = reinterpret_cast<f>(((int*)funx)[0]);
    x1();

    f funy = reinterpret_cast<f>(*(int*)(&y));
    f y1 = reinterpret_cast<f>(((int*)funy)[0]);
    y1();

    f funyx = reinterpret_cast<f>(*((int*)(&y) + 3));
    f yx1 = reinterpret_cast<f>(((int*)funyx)[0]);
    yx1();

    f funz = reinterpret_cast<f>(*(int*)(&z));
    f z1 = reinterpret_cast<f>(((int*)funz)[0]);
    z1();

    f funzx = reinterpret_cast<f>(*((int*)(&z) + 2));
    f zx1 = reinterpret_cast<f>(((int*)funzx)[0]);
    zx1();

    f funm = reinterpret_cast<f>(*(int*)(&m));
    f m1 = reinterpret_cast<f>(((int*)funm)[0]);
    m1();

    f funmy = reinterpret_cast<f>(*((int*)(&m)));
    f my1 = reinterpret_cast<f>(((int*)funmy)[0]);
    my1();

    f funmz = reinterpret_cast<f>(*((int*)(&m) + 3));
    f mz1 = reinterpret_cast<f>(((int*)funmz)[0]);
    mz1();

    f funmx = reinterpret_cast<f>(*((int*)(&m) + 6));
    f mx1 = reinterpret_cast<f>(((int*)funmx)[0]);
    mx1();

    return 0;
}

在M的对象中，首先存放的是Y的子对象，需要注意的是：M中的虚函数地址存放在Y的子对象的虚函数表中，接下来是Z的子对象，然后是M的数据成员，最后是X的子对象。

运行时的内存结果如下：
在这里插入图片描述

程序运行结果如下：
在这里插入图片描述

x、y、z、m的内存布局如下：
在这里插入图片描述

在这里插入图片描述

Spring_24
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++对象数据成员存储示例
Spring_24的博客
05-05 483
本文以具体示例说明C++对象中数据成员的布局。
C++文件存取操作
重文-技艺山海经
03-27 1252
文件存取(File Access) 1. stream 可用来存取文件，C++标准库提供了四个template classes，并预先定义了四个标准特化版本： 1). basic_ifstream 2). basic_ofstream 3). basic_fstream 4). basic_filbuf 2. std::ofstream file(filename.c_str(
C/C++编程：数据成员的存取
OceanStar的博客
05-05 317
对于： Point3d origin, *ptr = &origin; origin.x = 0.0 *ptr->x = 0.0; 问题：x的存取成员是什么？ 回答：这得看x和Point3d是怎么声明的 问题：通过orgin存取和通过ptr存取，有什么重大差异吗？ 回答：有 静态数据成员 静态数据成员，被编译器提出于类之外，并被视为一个全局变量(但只在类生命范围之内可见) 每一个类的存取许可(即访问层级private/protected/public)，以及于类的关联，并不会导致任何空间上
浅谈C++中变量的存取方式
CSDN_LYY的专栏
01-03 1026
要访问一个变量，有两种方式，一种是用变量名，一种是使用地址，使用变量名属于直接访问，使用地址属于间接访问。 类比：如果一个同学住一个宿舍，你想找某个同学，如果你值得他的名字，你当然可以通过名字找到访问他，再者，如果你值得他的宿舍的地址，你也可以通过这个地址访问他。 程序中的变量也是一样，可以通过变量名直接访问，也可以通过变量在内存中的地址来间接访问。 在实际应用中，可能根本就没有变量名，或者
封装——为成员变量提供存取函数_GoogleC++风格命名
qq_60786476的博客
04-30 3496
任务描述 本关有一个未完成的类 Int，该类含有一个成员变量，请为该成员变量编写存取函数。存取函数以 Google C++ 风格命名，具体请参考主函数中的代码。 相关知识 封装是面向对象的特性之一。当类的成员设置为 private 之后，为了在类外访问该成员，必须提供存取函数。C++ 并没有一个广泛统一的存取函数的命名风格。各大公司都有一些相应的规范。Google 在其 C++ 开源项目中，提倡如下的命名规范。 如果类成员需要用单词 something 来描述，则该成员命名为 something_（注
C++指向类成员函数的指针详细解析
09-05
在C++中，指向类成员函数的指针是一种特殊的指针类型，它可以用来存储类的非静态成员函数的地址。这种指针与普通函数指针的主要区别在于，它需要一个对象实例来调用成员函数，因为成员函数是绑定到特定类的对象上的...
C++静态成员函数不能调用非静态成员变量(详解)
08-31
在C++编程语言中，静态成员函数和非静态成员函数有着显著的区别，这些差异主要体现在它们的作用域、存储方式以及如何访问类的成员。本文将深入探讨为什么C++的静态成员函数不能调用非静态成员变量，并通过示例进行...
如何获取C++类成员虚函数地址的示例代码
08-29
总结，获取C++虚函数地址的方法包括直接通过成员函数指针、使用内联汇编以及访问虚函数表。理解这些机制对于深入理解C++的虚函数机制和运行时类型信息的使用非常重要。不过，需要注意的是，这些操作通常属于底层编程...
关于C++静态成员函数访问非静态成员变量的问题
09-04
在C++编程语言中，静态成员函数和非静态成员函数有着显著的区别，这主要体现在它们的作用域、内存分配以及对对象状态的访问上。当我们讨论"关于C++静态成员函数访问非静态成员变量的问题"时，我们需要深入理解这两种...
C++获取类的成员函数的函数指针详解及实例代码
08-31
在C++编程语言中，获取类的成员函数的函数指针是一项重要的技术，它允许我们动态地调用对象的成员函数。下面将详细介绍这一概念，并通过实例代码进行解析。 首先，我们需要理解成员函数指针的概念。成员函数是类的...
c++ 常用函数
jinchengzhou的专栏
06-24 1664
C/C++头文件一览 C #include <assert.h>　　　　//设定插入点 #include <ctype.h>　　　　 //字符处理 #include <errno.h>　　　　 //定义错误码 #include <float.h>　　　　 //浮点数处理 #include <iso646.h> //对应...
C++成员函数在内存中的存储方式
热门推荐
Hopefully Sky的博客
03-01 3万+
用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了10个对象，那么就需要分别为10个对象的数据和函数代码分配存储单元，如下图所示。 能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。如下图所示。 显然，这样做会大大节约存储
C++成员函数的存储方式
ShenHang_的博客
08-22 1074
按理说，如果用同一个类定义了10个对象，那么就需要分别为10个对象的数据和函数代码分配存储单元，如图8.4所示。 能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。如图8.5所示。 显然，这样做会大大节约存储空间。C++编译系统正是这样做的，因此每个对象所占用的存储空间只是该对象的数据成员部分所占用的存储空间，而不包括函数代码所占用的存储空间。如果声...
27 C++ - 对象成员变量和函数的存储
阿甘兄
10-08 557
在c语言中，“分开来声明的，也就是说，语言本身并没有支持“数据”和“函数”之间的关联性我们把这种程序方法称为“程序性的”，由一组“分布在各个以功能为导航的函数中”的算法驱动，它们处理的是共同的外部数据。 c++实现了“封装”，那么数据(成员属性)和操作(成员函数)是什么样的呢？ “数据”和“处理数据的操作(函数)”是分开存储的。 c++中的非静态数据成员直接内含在类对象中，就像c struct一...
C++读写函数
Wang Bei的博客
11-04 1065
一、 fopen()、fwrite()、fread() 头文件：C的库函数，#include&lt;stdio.h&gt; 缓冲文件系统和非缓冲文件系统 a)缓冲文件系统 缓冲文件系统的特点是：在内存开辟一个“缓冲区”，为程序中的每一个文件使用，当执行读文件的操作时，从磁盘文件将数据先读入内存“缓冲区”， 装满后再从内存“缓冲区”依此读入接收的变量。执行写文件的操作时，先将数据写入内存“缓冲区”，...
C++类的成员函数存储方式（是否属于类的对象）
jiange_zh的博客
07-10 4556
今天在看TAF源码的时候，发现下面一段有趣的代码：getSmallerProxyPrx = Application::getCommunicator()->stringToProxy<GetSmallerPrx>(MobileAssist.JiangeSmallerServer.GetSmaller);//此处T为GetSmallerPrx template<class T> T stringTo
C++类与对象--成员函数的存储方式
qq_43414070的博客
10-30 673
C++类与对象--成员函数的存储方式类成员实际组成调用原理注意事项 类成员实际组成 用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了 10 个对象，那么就需要分别为 10 个对象的数据和函数代码分配存储单元。 那能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。如下图： 显然，这样做会大大节约存储空间。C++编译系统正是这样做的，因此每个对象所占用的存储空间只是该对象
c++ 文件读取函数总结
Sublele的专栏
09-17 8286
c++ 文件读取函数总结IO相关类继承关系 本文讲解文件读写，因此主要介绍<fstream>相关类以及<stdio.h>的fopen。
c++类成员函数作为回调函数
最新发布
07-28
3. 回调函数指针或函数对象需要存储类的实例指针，以便在回调时调用类的成员函数。这可以通过将类实例指针作为额外的参数传递给回调函数来实现。 4. 如果回调函数需要访问类的非静态成员变量或其他非静态成员函数，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值