C++对象模型分析

面向对象分析与设计——对象模型 2           对象模型  对象模型包括:抽象、封装、模块化、层次结构、类型、并发和持久   2.1   对象模型的演进   OO建立在以前技术的最佳思想之上。两大趋势:小规模→大规模;高级程序设计语言;   2.1.1    程序设计语言的换代   l        第一代(1954~1985):科学和工程应用,公式计算 FORTRANⅠ 数学表达式   l    阅读详情

1 class本质分析

1.1 class本质

class是一种特殊的struct:

  • 在内存中class依旧可以看作变量的集合。
  • class与struct遵循相同的内存对齐规则。
  • class中的成员函数与成员变量是分开存放的:
    • 每个对象有独立的成员变量。
    • 所有对象共享类中的成员函数。

值得思考的问题:
在这里插入图片描述
对象内存布局初探:

#include <iostream>
#include <string>

using namespace std;

class A
{
    int i;
    int j;
    char c;
    double d;
public:
    void print()
    {
        cout << "i = " << i << ", "
             << "j = " << j << ", "
             << "c = " << c << ", "
             << "d = " << d << endl;
    }
};

struct B
{
    int i;
    int j;
    char c;
    double d;
};

int main()
{
    A a;
    
    cout << "sizeof(A) = " << sizeof(A) << endl;    // 20 bytes
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;    // 20 bytes
    
    a.print();
    
    B* p = reinterpret_cast<B*>(&a);
    
    p->i = 1;
    p->j = 2;
    p->c = 'c';
    p->d = 3;
    
    a.print();
    
    p->i = 100;
    p->j = 200;
    p->c = 'C';
    p->d = 3.14;
    
    a.print();
    
    return 0;
}

运行时的对象退化为结构体的形式:

  • 所有成员变量在内存中依次排布。
  • 成员变量可能存在内存空隙。
  • 可以通过内存地址直接访问成员变量。
  • 访问权限关键字在运行时失效。

2 非继承对象模型分析

2.1 非继承对象模型分析

对象模型分析:

  • 类中的成员函数位于代码段中。
  • 调用成员函数时对象地址作为参数隐式传递。
  • 成员函数通过对象地址访问成员变量。
  • C++语法规则隐藏了对象地址的传递过程。

下面用C语言实现如下C++代码:

#include <iostream>
#include <string>

using namespace std;

class Demo
{
    int mi;
    int mj;
public:
    Demo(int i, int j)
    {
        mi = i;
        mj = j;
    }
    
    int getI()
    {
        return mi;
    }
    
    int getJ()
    {
        return mj;
    }
    
    int add(int value)
    {
        return mi + mj + value;
    }
};

int main()
{
    Demo d(1, 2);
    
    cout << "sizeof(d) = " << sizeof(d) << endl;
    cout << "d.getI() = " << d.getI() << endl;
    cout << "d.getJ() = " << d.getJ() << endl;
    cout << "d.add(3) = " << d.add(3) << endl;
    
    return 0;
}

demo.h:

#ifndef _50_2_H_
#define _50_2_H_

typedef void Demo;

Demo* Demo_Create(int i, int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis, int value);
void Demo_Free(Demo* pThis);

#endif

demo.c:

#include "50-2.h"
#include "malloc.h"

struct ClassDemo
{
    int mi;
    int mj;
};

Demo* Demo_Create(int i, int j)
{
    struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));
    
    if( ret != NULL )
    {
        ret->mi = i;
        ret->mj = j;
    }
    
    return ret;
}

int Demo_GetI(Demo* pThis)
{
     struct ClassDemo* obj = (struct ClassDemo*)pThis;
     
     return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
     
    return obj->mj;
}

int Demo_Add(Demo* pThis, int value)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
     
    return obj->mi + obj->mj + value;
}

void Demo_Free(Demo* pThis)
{
    free(pThis);
}

main.c:

#include <stdio.h>
#include "50-2.h"

int main()
{
    Demo* d = Demo_Create(1, 2);             // Demo* d = new Demo(1, 2);
    
    printf("d.mi = %d\n", Demo_GetI(d));     // d->getI();
    printf("d.mj = %d\n", Demo_GetJ(d));     // d->getJ();
    printf("Add(3) = %d\n", Demo_Add(d, 3));    // d->add(3);
    
    // d->mi = 100;
    
    Demo_Free(d);
    
    return 0;
}

3 继承对象模型分析

3.1 继承对象模型

继承对象模型:

  • 在C++编译器的内部类可以理解为结构体。
  • 子类是由父类成员叠加子类新成员得到的。

在这里插入图片描述

3.2 多态对象模型

C++多态的实现原理:

  • 当类中声明虚函数时,编译器会在类中生成一个虚函数表。
  • 虚函数表是一个存储成员函数地址的数据结构。
  • 虚函数表是由编译器自动生成与维护的。
  • virtual成员函数会被编译器放入虚函数表中。
  • 存在虚函数时,每个对象中都有一个指向虚函数表的指针(位于最前面)。

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

继承对象模型示例:

#include <iostream>
#include <string>

using namespace std;

class Demo
{
protected:
    int mi;
    int mj;
public:
    virtual void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << endl;
    }
};

class Derived : public Demo
{
    int mk;
public:
    Derived(int i, int j, int k)
    {
        mi = i;
        mj = j;
        mk = k;
    }
    
    void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << ", "
             << "mk = " << mk << endl;
    }
};

struct Test
{
    void* p;
    int mi;
    int mj;
    int mk;
};

int main()
{
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl;         
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;  
    
    Derived d(1, 2, 3);
    Test* p = reinterpret_cast<Test*>(&d);
    
    cout << "Before changing ..." << endl;
    
    d.print();
    
    p->mi = 10;
    p->mj = 20;
    p->mk = 30;
    
    cout << "After changing ..." << endl;
    
    d.print();
    
    return 0;
}

用C语言实现多态特性:
demo.h:

#ifndef _51_2_H_
#define _51_2_H_

typedef void Demo;
typedef void Derived;

Demo* Demo_Create(int i, int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis, int value);
void Demo_Free(Demo* pThis);

Derived* Derived_Create(int i, int j, int k);
int Derived_GetK(Derived* pThis);
int Derived_Add(Derived* pThis, int value);

#endif

demo.c:

#include "51-2.h"
#include "malloc.h"

static int Demo_Virtual_Add(Demo* pThis, int value);
static int Derived_Virtual_Add(Demo* pThis, int value);

struct VTable     // 2. 定义虚函数表数据结构
{
    int (*pAdd)(void*, int);   // 3. 虚函数表里面存储什么???
};

struct ClassDemo
{
    struct VTable* vptr;     // 1. 定义虚函数表指针  ==》 虚函数表指针类型???
    int mi;
    int mj;
};

struct ClassDerived
{
    struct ClassDemo d;
    int mk;
};

static struct VTable g_Demo_vtbl = 
{
    Demo_Virtual_Add
};

static struct VTable g_Derived_vtbl = 
{
    Derived_Virtual_Add
};

Demo* Demo_Create(int i, int j)
{
    struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo)); 

    if( ret != NULL )
    {
        ret->vptr = &g_Demo_vtbl;   // 4. 关联对象和虚函数表
        ret->mi = i;
        ret->mj = j;
    }
    
    return ret;
}

int Demo_GetI(Demo* pThis)
{
     struct ClassDemo* obj = (struct ClassDemo*)pThis;    

     return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->mj;
}

// 6. 定义虚函数表中指针所指向的具体函数
static int Demo_Virtual_Add(Demo* pThis, int value)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
    
    return obj->mi + obj->mj + value;
}


// 5. 分析具体的虚函数!!!!
int Demo_Add(Demo* pThis, int value)
{

    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->vptr->pAdd(pThis, value);
}

void Demo_Free(Demo* pThis)
{
    free(pThis);
}

Derived* Derived_Create(int i, int j, int k)
{
    struct ClassDerived* ret = (struct ClassDerived*)malloc(sizeof(struct ClassDerived));
    
    if( ret != NULL )
    {
        ret->d.vptr = &g_Derived_vtbl;
        ret->d.mi = i;
        ret->d.mj = j;
        ret->mk = k;
    }
    
    return ret;
}

int Derived_GetK(Derived* pThis)
{
    struct ClassDerived* obj = (struct ClassDerived*)pThis;
    
    return obj->mk;
}

static int Derived_Virtual_Add(Demo* pThis, int value)
{
    struct ClassDerived* obj = (struct ClassDerived*)pThis; 

    return obj->mk + value;
}

int Derived_Add(Derived* pThis, int value)
{   
    struct ClassDerived* obj = (struct ClassDerived*)pThis;
    
    return obj->d.vptr->pAdd(pThis, value);
}

main.c:

#include "stdio.h"
#include "51-2.h"

void run(Demo* p, int v)
{
    int r = Demo_Add(p, v);
    
    printf("r = %d\n", r);
}

int main()
{
    Demo* pb = Demo_Create(1, 2);
    Derived* pd = Derived_Create(1, 22, 333);
    
    printf("pb->add(3) = %d\n", Demo_Add(pb, 3));
    printf("pd->add(3) = %d\n", Derived_Add(pd, 3));
    
    run(pb, 3);
    run(pd, 3);
    
    Demo_Free(pb);
    Demo_Free(pd);
    
    return 0;
}

参考资料:

  1. C++深度解析教程
面向对象的分析(Object Oriented Analysis,OOA)模型有三种:功能模型 (用例图)对象模型(类图) 动态模型(状态图) 面向对象的分析(Object Oriented Analysis,OOA),运用面向对象方法对问题域和系统责任进行分析和理解,找出所需的对象,定义对象的属性、操作以及它们之间的关系。其目标是建立一个符合问题域、满足用户需求的OOA模型。需要知道OOA的原则有什么。OOA的主要原则如下:(1)抽象:从许多事物中舍弃个别的、非本质的特征,抽取共同的、本质性的特征,就叫作抽象。抽象是形成概念的必须手段。抽象是面向对象方法中使用最为广泛的原则。抽象原则包括过程抽象和数据抽象两个方面。(2)封装:就是把对象的属性和服 阅读详情

相关推荐

Keil调试技巧:3种方法查看Cortex-M4的SCB寄存器(含CPUID内存映射解析)

本文详细介绍了在Keil MDK中查看Cortex-M4内核SCB寄存器的三种实战方法:使用Watch窗口进行符号化观察、通过Memory窗口直接查看物理内存映射,以及利用SFR寄存器浏览器解析位域信息。文章重点解析了CPUID寄存器的内存映射地址(0xE000ED00)及其位域含义,帮助开发者深入理解处理器身份识别与底层调试技巧,提升嵌入式系统调试效率。

h6i7j8的博客 574

面向对象分析(OOA)——如何开始做一个像样的”项目“?如何分析别人的项目?

面向对象分析(OOA)面向对象设计(OOA)阶段三大模型一、功能模型功能模型和用例图用例图的简单组成二、动态模型动态模型的描述动态模型设计启发方法三、对象模型对象启发欢迎关注我、一起共勉 面向对象设计(OOA)阶段三大模型 功能模型:用例图简要的揭示系统需要实现的功能 动态模型:以时序图的形式展现用户交互发生过程 对象模型:使用类图表示系统需要设计的对象 一、功能模型 功能模型和用例图 功能模型指描述系统功能的模型,可以有多种实现方式,但最常使用用例图描述。以下是用例图的相关描述 尽管用例本身会涉及大

代码之狐的博客 3864

生成式引擎优化(GEO)全景指南:技术架构、实施策略与未来趋势

生成式引擎优化(GEO)全景指南摘要 GEO(生成式引擎优化)是针对AI生成内容(如ChatGPT、文心一言等)的优化策略,通过结构化数据、权威建设与语义优化提升企业内容在AI答案中的引用优先级,实现“无点击曝光”。其核心价值在于从流量竞争转向信任构建,突破传统SEO局限。技术架构依托RAG(检索增强生成)、向量数据库及反馈学习机制,动态优化内容生成与引用逻辑。实施策略包括:部署结构化数据(如JSON-LD)、维护动态知识图谱、适配多模态内容(3D/VR)、联合权威机构发布白皮书。行业案例显示,美妆、智能家

解锁AI流量新红利!🚀 GEO优化(生成引擎优化)助您掌控AI搜索,让AI成为您的品牌最佳代言人! 1454

分析模式——可复用的对象模型

最近读了《分析模式——可复用的对象模型》一书,这本书算是DDD方面的一本启蒙书籍,阅读完成后还是受益良多,一方面是很多观点和平时的工作相互印证,很受启发,另一方面学到了一些业务建模的模式,本文主要总结一下收到启发的地方和建模原则,具体的建模方式举一个例子体会一下就好。

weixin_47588164的博客 1340

阿里数据集(cluster-trace-v2018)提取

阿里数据集提取 本数据集采用的是阿里集群数据集-2018 详情可参考该文献:https://blog.youkuaiyun.com/weixin_41988248/article/details/92431588 CSV数据集提取操作见:https://blog.youkuaiyun.com/lucky_shi/article/details/105321149 关于read_csv包的用法见:https://blog.youkuaiyun.com/dc19971118/article/details/107721340 从阿里数据集来看,我

5-StarrySky的博客 3344

课程1:认识Asp.net Core Web API

本文是《.Net Core从零学习搭建权限管理系统》教程专栏的导航站(点击链接,跳转到专栏主页,欢迎订阅,持续更新…)专栏介绍:以实战为线索,基于.Net 7 + REST + Vue、前后端分离,不依赖任何第三方框架,从零一步一步讲解权限管理系统搭建。专栏适用于人群:Web后端开发人员Web API是一个很广泛的概念,Asp.net Core Web API是.NET框架用于创建RESTful风格的项目、用于轻松构建可供多个客户端访问的HTTP服务。1、支持RestFul风格编程;

成长的足迹 1256

实验报告: 研究C++的对象模型

分析主函数中的局部对象可以发现,一般类型的数据成员依然在对象的内存空间中,特殊类型的成员在对象之外,但是其内存空间的顺序发生了改变,int&类型的_selectedCourseNum变量依然保存在对象之前,并且与对象起始地址保持着一段并不远的距离,但是成员函数以及静态数据成员都在类之后,并且距离类有很长一个跳跃。cout本质上是运算符重载,因此,在某些特殊类型的输出上受到了限制,可能会因此产生bug,例如函数的输出,在某些编译器中,cout并没有重载函数类型相关的输出,因此在输出前必须转化为其他类型。

m0_66829891的博客 1331

60、拓扑码:从理论到应用

本博客深入探讨了拓扑码的基本理论、构造方法及其在量子计算中的应用。重点介绍了颜色码的拓扑起源、编码量子比特的计算方法、弦算子的构造与性质、边界条件的影响、同调描述以及与统计模型相关的错误阈值分析。同时,还涵盖了拓扑码的历史发展、与其他拓扑码的关系、与凝聚态系统的联系,以及其在激发态和高维中的表现。博客展示了拓扑码在容错量子计算和未来量子信息领域的广阔前景。

o1p2q3r的博客 129

[lesson51]C++对象模型分析(下)

在C++中编译器的内部类可以理解为结构体子类是由父类成员叠加子类新成员得到的。

James的博客 384

《基于YOLOv5/8/10的足球比赛球员识别系统毕设全指南:从开发到部署的一站式实战》

本文提出了一个基于YOLO系列模型的足球球员识别系统,具备完整的开发流程和技术方案。系统通过YOLOv5/8/10三大框架实现球员检测,平衡精度与速度需求。开发过程包含数据标注与增强、模型训练调优、PyQt5界面开发等关键环节,并提供了模型轻量化、多任务扩展等优化方向。系统可实现单张图像和视频流的实时识别,支持跨设备部署,适用于赛事分析和训练复盘场景。项目特色在于完整的技术实现路径和对不同YOLO框架的性能对比,为计算机视觉在体育领域的应用提供实践参考。

m0_71589036的博客 217

基于BEV(鸟瞰图)的3D检测:PointPillars与CenterPoint

基于BEV(鸟瞰图)的3D检测:PointPillars与CenterPoint​ ,人工智能,计算机视觉,大模型,AI,本文围绕基于BEV的3D检测,解析了PointPillars与CenterPoint两种算法。PointPillars用点柱特征编码网络处理点云,通过2D卷积网络提取特征,检测头为解耦头;CenterPoint将三维物体表为点,分两阶段检测,先找中心点及属性,再细化预测。两者都可借特定骨干网生成BEV特征图且基于BEV检测,但检测头设计和物体表示方式不同。

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 27万+

C++进阶剖析(二十一)之对象模型分析

1.1对象模型分析 1.1.1 对象模型分析的本质 C++中的对象分为两个部分:对象的成员变量和对象的成员函数,对象模型分析就是对对象的成员变量和成员函数进行分析。 1.1.2类对象的本质 class 是一种特殊的struct 在内存中class依旧可以看做变量的集合 class 与struct 遵循相同的内存对齐规则 class中的成员变量和成员函数是分开存放的 (1)每个对象都有独立的成员变...

海是倒过来的天的博客 233

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

C++--C++对象模型分析、c++中的抽象类和接口

一.C++对象模型分析 A.class是一种特殊的struct 1.在内存中class依旧可以看作变量的合集 2.在class域struct遵循相同的内存对齐规则 3.class中的成员函数与成员变量是分开存放的–每个对象有独立的成员变量,所有对象共享类中的成员函数 Q:class与struct的内存占用情况? #include <iostream> #include <stri...

weixin_45189747的博客 151

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

C++ 多重继承和虚拟继承对象模型、效率分析

一、多态 C++多态通过继承和动态绑定实现。继承是一种代码或者功能的传承共享,从语言的角度它是外在的、形式上的,极易理解。而动态绑定则是从语言的底层实现保证了多态的发生——在运行期根据基类指针或者引用指向的真实对象类型确定调用的虚函数功能!通过带有虚函数的单一继承我们可以清楚的理解继承的概念、对象模型的分布机制以及动态绑定的发生,即可以完全彻底地理解多态的思想。为了支持多态,语言实现必须在时间和空...

a13602955218的博客 452

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

C++之对象模型分析

对象模型分析 class是一种特殊的struct 1、在内存中class依旧可以看成变量的集合; 2、class与struct遵循相同的内存对齐规则; 3、class中的成员变量与成员函数是分开存放的; 1)、每个对象有独立的成员函数; 2)、所有对象共享类中的成员函数 运行时对象退化为结构体的形式 1、所有的成员变量在内存中依次排布; 2、成员变量间可能存在内存空隙; 3、可以通过内存地址直接访问成员变量; 4、访问权限关键字在运行时失效。 类中的成员函数是位于代码段的 调用成员函数时对象地址作

weixin_43985500的博客 144

9、c++对象模型分析

此文编写参考狄泰软件学院唐佐林老师的视频课程,如有错误之处,欢迎指正。 一、回归本质 1、关于对成员变量的探索 class是一种特殊的struct 在内存中class依旧可以看成是变量的集合 class与struct遵循相同的内存对齐规则 class中的成员变量和成员函数是分开存放的 (1)每个对象都有独立的成员变量,这个变量可能存在于栈、堆或者全局数据区 (2)多有对象共享类中的成员函数,该成员函数只可能存在于代码段 下面通过一个实例来理解上述内容 #include<iostream> #

wuzhishiwo的博客 248

50-C++对象模型分析(上)

注:博客中内容主要来自《狄泰软件学院》,博客仅当私人笔记使用。 测试环境:Ubuntu 10.10 GCC版本:9.2.0 一、回归本质 1)class是一种特殊的struct - 在内存中class依旧可以看作变量的集合 - class与struct遵循相同的内存对齐规则 - class中的成员函数与成员变量是分开存放的 * 每个对象有独立的成员变量 * 所有对象共享类中的成员函数 2)值得思考的问题...

第一大剑豪——索隆 255

C++ 对象模型分析(下)

第51课 - C++ 对象模型分析(下) 继承对象模型 在 C++ 编译器的内部类可以理解为结构体 子类是由父类成员函数叠加子类新成员得到的 class Derived : public Demo { int mk; }; 编程实验1 :继承对象模型初探 #include <iostream> #include <string> using names...

zhabin0607的博客 221

C++:虚继承中对象模型分析

前言 我们知道 在多继承中,特别是 菱形继承中,会有两个问题: 内存的浪费。 二义性。 所以 引进了虚继承来 解决问题,虚继承和虚函数的原理很类似。 虚继承有 vbptr(虚基类指针) 指向 vbtable(虚基类表)。 那底层到底如何实现,我们 从 类的对象模型来分析。 对象模型分析 工具: vs 开发工具 命令: cl /d1reportSingleClassLayout[className] XXX.cpp 测试类 我们来看 类Bb 和 Cc 是怎样的布局: Cc 同理,我们就不演示了。

qq_45853229的博客 1104

C++多重继承和虚拟继承对象模型、效率分析

本文简单介绍多态和多重继承、虚拟继承的基本概念。随后重点分析了C++中对象模型之间的差异和运行效率。 一、多态        C++多态通过继承和动态绑定实现。继承是一种代码或者功能的传承共享,从语言的角度它是外在的、形式上的,极易理解。而动态绑定则是从语言的底层实现保证了多态的发生——在运行期根据基类指针或者引用指向的真实对象类型确定调用的虚函数功能!通过带有虚函数的单一继承我们可

Ocean2006的专栏 5281

【C++基础入门】44.C++中对象模型分析(上)

C++中对象模型深入分析

老胡的博客 453

Hello C++(十三)——C++对象模型分析

一、C++对象模型分析 1、类对象模型的内存布局 class是一种特殊的struct,class与struct遵循相同的内存对齐原则,class中的成员函数与成员变量是分开存放的,每个对象拥有独立的成员变量,所有的对象共享类中的成员函数。 运行时,类对象退化为结构体的形式: A、所有成员变量在内存中依次排布 B、由于内存对齐的存在,成员变量间可能存在内存间隙 C、可以通过内存地址访问成员变量 D、访问权限关键字在运行时失效 #include<iostream> usingn..

天山老妖 510
上一篇: C++中多态的概念和意义
下一篇: C++中的抽象类
SlowIsFastLemon
博客等级 码龄8年 265粉丝 790原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值