对象多继承中的数据结构分析

Python面向对象中的super详解 Python中关键字super主要用来调用父类的方法,当我们调用 super() 的时候,实际上是实例化了一个 super 类,而非关键字或者函数等其它数据结构。在大多数情况下,super 包含了两个非常重要的信息: 一个 MRO (方法解析顺序)以及 MRO 中的一个类 阅读详情

为了探索类继承数据结构,构造如下几个类:

 

Class BaseA:

Class BaseB public BaseA

Class BaseC

Class BaseD

Class BaseE public BaseC, public BaseD

Class DriveF public BaseB, public BaseE

 

  类继承示意图

 

代码:

#include <iostream>

using namespace std;

 

class BaseA {

public:

    BaseA() {cout << "In BaseA/n";}

    virtual void fa() { cout << "BaseA::fa/n"; }

    virtual void faa() { cout << "BaseA::faa/n"; }

    int a;

};

 

class BaseB  : public BaseA {

public:

    BaseB () {cout << "In BaseB /n"; }

    virtual void fb() { cout << "BaseB ::fb/n"; }

    virtual void fbb() { cout << "BaseB ::fbb/n"; }

    int b;

};

 

class BaseC  {

public:

    BaseC () {cout << "In BaseC /n";}

    virtual void fc() { cout << "BaseC ::fc/n"; }

    virtual void fcc() { cout << "BaseC ::fcc/n"; }

    int c;

};

 

class BaseD {

public:

    BaseD() {cout << "In BaseD/n";}

    virtual void fd() { cout << "BaseD::fd/n"; }

    virtual void fdd() { cout << "BaseD::fdd/n"; }

    int d;

};

 

class BaseE : public BaseC , public BaseD

{

public:

    BaseE() {cout << "In BaseE/n"; }

    virtual void fe() { cout << "BaseE::fe/n"; }

    virtual void fee() { cout << "BaseE::fee/n"; }

    int e;

};

 

class DriveF : public BaseB , public BaseE

{

    public:

    DriveF(){cout << "In DriveF/n";}

    virtual void ff(){cout << "DriveF::ff/n"; }

    virtual void fff(){cout << "DriveF::fff/n"; }

    int f;

};

 

typedef void(*F)(void);

 

int main(void)

{

    cout << "/n创建BaseA对象/n";

    BaseA ba;

    ba.a = 9;

 

    int *pob  = (int*)(&ba) ;                  //对象地址

    int *pvt = (int*)(*pob) ;                  //对象的虚表地址

    F f = F( *pvt );                           //虚表第一个虚函数

f();

f = F( *(pvt+1) );                         //虚表第二个虚函数

    f();

 

    cout << "BaseA.a = " << *(pob+1) << "/n";    //数据成员a

   

    cout << "/n创建BaseB 对象/n";

    BaseB  bb;

    bb.a = 8; bb.b=7;

 

    pob  = (int*)(&bb) ;                 //对象地址

    pvt = (int*)(*pob) ;                 // BaseB虚表

    f = F( *pvt );                              //BaseA第一个虚函数

    f();

    f = F( *(pvt+1) );                          //BaseA第二个虚函数

    f();

 

    f = F( *(pvt+2) );                           //BaseB虚表第一个虚函数

    f();

    f = F( *(pvt+3) );                           //BaseB虚表第二个虚函数

    f();

    cout << "BaseB.BaseA.a = " << *(pob+1) << "/n";  //BaseA数据成员a

    cout <<"BaseB.b = " <<*(pob+2 ) << "/n";       //BaseB数据成员b

   

    cout << "/n创建DriveF对象/n";

    DriveF df;

    df.a = 1,

    df.b = 2;

    df.c = 3;

    df.d = 4;

    df.e = 5;

    df.f = 6;

 

    pob  = (int*)(&df) ;       //对象地址

    pvt = (int*)(*pob) ;        //对象的虚表地址

 

    F f4 = F( *pvt );           //BaseA 第一个虚函数

    f4();

    f4 = F( *(pvt+1) );         //BaseA 第二个虚函数

    f4();

 

    F f5 = F( *(pvt+2) );       // BaseB 第一个虚函数

    f5();

    f5 = F( *(pvt+3) );         // BaseB 第二个虚函数

    f5();

 

    F f6 = F( *(pvt+4) );       //DriveF 第一个虚函数

    f6();

    f6 = F( *(pvt+5) );         //DriveF 第二个虚函数

    f6();

 

    F f7 = F( *(int*)*(pob+3) );    //BaseC  第一个虚函数

    f7();

    f7 = F( *((int*)*(pob+3)+1) );  //BaseC  第二个虚函数

    f7();

 

    F f8 = F( *(int*)*(pob+5) );    //BaseD 第一个虚函数

    f8();

    f8 = F( *((int*)*(pob+5)+1) );  //BaseD 第二个虚函数

    f8();

 

    F f9 = F( *( (int*)*(pob+3)+2 ) );  //BaseE 第一个虚函数

    f9();

    f9 = F( *( (int*)*(pob+3)+3 ) );    //BaseE 第二个虚函数

    f9();

 

    cout <<"DriveF.BaseB.BaseA.a = "<< *(pob+1) << "/n";//BaseA数据成员a

    cout <<"DriveF.BaseB.b = " <<*(pob+2 ) << "/n";    //BaseB数据成员b

    cout <<"DriveF.BaseC.c = " <<*(pob+4) << "/n";     //BaseC 数据成员c

    cout <<" DriveF.BaseD.d = " <<*(pob+6) << "/n";    //BaseD数据成员d

    cout <<" DriveF.BaseE.e = " <<*(pob+7) << "/n";    //BaseE数据成员e

    cout <<"DriveF.f = " <<*(pob+8) << "/n";           //DriveF数组成员f

 

    return 0;

}

 

结论图示:

类继承数据结构

C++-RTTI-运行时类型识别-typeid类型名-dynamic_cast-多继承类型转换-详细分析-Com基础 为什么作者花这么多精力来整理这个RTTI,因为这个是C++高级技术多继承中必然的一环,在windows系统中随处可见的Com模块,它的基础技术就是C++的多继承,除了要了解多继承的内存结构,也要了解多继承的类型识别,以及父子类型的动态转换,这样才能理解Com模块设计思路,在将来的软件互操作设计中,才能从底层了解,技术上为啥这样设计。 阅读详情

相关推荐

NXP KW45开发实战:如何在MCUXpresso IDE中正确配置J-Link并解决设备识别问题

本文详细介绍了在MCUXpresso IDE中配置J-Link以支持NXP KW45无线MCU开发的实战指南。从环境准备到J-Link深度配置,再到烧录流程优化和高级调试技巧,帮助开发者高效解决设备识别问题并提升开发效率。特别推荐使用JLinkRemoteServer.exe进行多设备并行调试,并提供了烧录速度优化和低功耗调试的实用技巧。

gray5的博客 867

C++ 多继承

派生类都只有一个基类,称为单继承(Single Inheritance)。除此之外,C++也支持多继承(Multiple Inheritance),即一个派生类可以有两个或多个基类。 多继承的语法也很简单,将多个基类用逗号隔开即可。例如已声明了类A、类B和类C,那么可以这样来声明派生类D: class D: public A, private B, protected C{ //类D新增加...

weixin_45743799的博客 1550

PointMLP实战:5分钟用PyTorch搭建点云分类模型(附GitHub代码)

本文提供了基于ICLR 2022论文PointMLP的点云分类模型实战教程。通过PyTorch框架,详细介绍了从环境搭建、数据预处理、模型架构解析到训练推理的全流程,并分享了性能调优技巧。该模型利用残差MLP模块构建,结构清晰高效,适合开发者快速上手并应用于实际点云处理项目。

r2s3t4的博客 216

深度探索c++对象模型-14-多重继承数据布局与this调整深谈

一、单一继承数据成员布局this指针偏移知识补充 上一节我们知道,子类没有虚函数,而子类有虚函数的单一继承中,布局如下: 因为vptr的地址在开始,所以当访问父类的m_bi的时候,将会进行this指针调整,也就是调整4个字节。 下面看代码改造,看看实际的this指针调整 class father { public: int m_fi; father() { printf("father:father()的this指针调整:%p\n", this); } }; class MYCLASS:p

FairLikeSnow的博客 519

免疫治疗新思路:用COMPASS算法挖掘单细胞数据中的代谢靶点(含差异分析技巧)

本文介绍了如何利用COMPASS算法从单细胞转录组数据中系统推断免疫细胞的代谢活性,为肿瘤免疫治疗提供新的靶点发现思路。文章详细阐述了COMPASS结合流平衡分析的核心原理,并提供了从差异分析到可成药性评估的完整转化路径,旨在帮助研究者精准定位代谢弱点,开发新型免疫代谢疗法。

weixin_29275257的博客 368

MySQL安装配置教程(超级详细)

一、 下载MySQL Mysql官网下载地址:MySQL :: Download MySQL Installer (Archived Versions) 1. 选择要安装的版本,本篇文章选择的是5.7.31版本,点击Download下载 正在上传…重新上传取消 二、 安装MySQL 1. 选择设置类型双击运行mysql-installer-community-5.7.31.0.msi 这里选择是自定义安装,所以直接选择“Custom”,点击“Next” “Developer Default”是

m0_67322837的博客 5万+

C++(23)——理解多重继承(菱形继承、半圆形继承)、虚基类和虚继承

多重继承 概念: 一个派生类如果只继承一个基类,称作单继承,那么如果继承了多个基类,就称作多继承。 比如: class C:public A,public B{}; 多重继承的优点: 多重继承可以做更多的代码复用! 派生类通过多重继承,可以得到多个基类的数据和方法,更大程度的实现了代码复用。 多重继承有优点,那就也会存在缺陷: 首先我们通过菱形继承了解一下多重继承的缺陷: 菱形继承 菱形继承是多继承的一种: 如下图所示: 图中的继承关系会产生什么样的问题呢? 我们通过如下的代码示例理解一下: class

qq_44824574的博客 1万+

USB设备识别码VID和PID详解:如何查询和自定义你的设备ID

本文详细解析了USB设备识别码VID和PID的核心作用、查询方法及自定义配置技巧。VID(供应商识别码)和PID(产品识别码)是USB设备的唯一身份证,用于驱动匹配和功能识别。文章提供了Windows和Linux系统下的查询方法,并探讨了如何合法获取和自定义VID/PID,适合硬件开发者和DIY爱好者参考。

weixin_29168675的博客 1504

多继承类的虚表结构(感觉这个讲的不错,整理出来)

原文出自:http://bbs.youkuaiyun.com/topics/390853050 @lisong694767315的回答对于多重继承,如果类定义了虚函数,该类及其派生类就要生成一张虚拟函数表。如下继承关系(没有覆盖):在子类Derive实例中的虚函数表:子类自己定义的虚函数会被放到了第一个基类的虚函数表中。如果子类重写了基类的虚函数,则在虚函数表中,子类函数会覆盖相应的基类函数:以上继承重写了

zjq9931的专栏 2073

基于经验模态分解和核主成分分析结合长短期记忆网络EMD-KPCA-LSTM的光伏功率预测算法--Matlab

基于经验模态分解和核主成分分析结合长短期记忆网络EMD-KPCA-LSTM的光伏功率预测算法--Matlab

前程算法屋的博客 629

【RT-DETR实战】117、华为昇腾CANN部署探索:从模型转换到推理踩坑实录

本文总结了RT-DETR模型在昇腾310B芯片上部署的关键挑战与解决方案。主要遇到四大问题:1)模型转换时需注意ONNX导出设置,建议先固定尺寸验证;2)内存布局差异导致推理异常,需精确匹配NHWC/NCHW格式;3)流水线并发优化中内存复用和异步处理是关键;4)调试阶段需利用专用工具逐层比对。作者提出六条实用建议,包括小尺寸验证、预处理对齐、内存池设计等,强调部署是持续适配过程,需建立完整的测试体系应对工具链迭代。

企鹅码农的专属播客,分享10多年的实战案例和经验解读,包含YOLO、RT-DETR、AI等各个工作领域。 195

多继承的构造顺序

构造对象的规则需要扩展以控制多重继承。构造函数按下列顺序被调用:   (1)任何    虚拟基类的构造函数按照它们被继承的顺序构造;(#add 即声明顺序)   (2)任何非虚拟基类的构造函数按照它们被继承的顺序构造;   (3)任何成员对象的构造函数按照它们声明的顺序调用;   (4)类自己的构造函数。   例如:     //**********************

把握自己。 2160

核心组件大换血:Backbone与Neck魔改篇:YOLO26魔改Neck:引入BiFPN(双向特征金字塔),多尺度融合能力飙升

本文深入解析了YOLO26目标检测模型中Neck部分的优化策略,重点探讨了BiFPN(双向特征金字塔网络)的原理与实现。文章首先指出YOLO26原生FPN+PAN结构在多尺度特征融合上的局限性,特别是在小目标检测和边缘部署场景中的性能瓶颈。随后系统梳理了Neck网络的演进历程,从FPN、PANet到BiFPN和ASFF,详细对比了各架构的特点。核心部分展示了如何将BiFPN引入YOLO26,包括可学习权重融合、双向跨尺度连接等关键技术实现,并提供了PyTorch代码示例。本文为需要提升小目标检测性能或优化边

ZDQ58818的博客 248

C++中的父继子承(2)多继承菱形继承问题,多继承指针偏移,继承组合分析+高质量习题扫尾继承多态

🔍 摘要: 本文探讨C++继承中的关键技术问题: 禁止继承的两种方法:父类构造函数私有化(子类无法调用)或使用final修饰父类。 友元与继承:友元关系不可继承,需在派生类中重新声明。 静态成员在继承体系中唯一,所有子类共享同一静态变量。 菱形继承引发二义性与数据冗余,通过虚继承(virtual)解决,但增加了复杂度。 多继承指针偏移:基类指针指向派生类时,地址因内存布局(声明顺序)可能不同,需注意类型转换时的隐式调整。 ⚡ 核心结论: 菱形继承应避免,虚继承慎用;多继承需警惕指针偏移问题,优先使用单一继

asciiletters的博客 1063

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

python单继承和多继承_Python中的单继承与多继承实例分析

本文实例讲述了Python中的单继承与多继承。分享给大家供大家参考,具体如下:单继承一、介绍Python 同样支持类的继承,如果一种语言不支持继承,类就没有什么意义。派生类的定义如下所示:class DerivedClassName(BaseClassName1):...需要注意圆括号中基类的顺序,若是基类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从...

weixin_39594296的博客 181

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

C++面向对象继承全面解析:不能被继承的类、多继承、菱形虚拟继承与设计模式实践

本文探讨C++继承机制的核心问题。实现不可继承类有两种方式:传统方法通过私有化构造函数,C++11引入final关键字直接禁止派生。友元关系不可继承,而静态成员在继承体系中共享。 多继承中的菱形继承问题尤为关键,会导致数据冗余和访问二义性。通过虚继承可解决此问题,确保公共基类在继承体系中只有一个实例。 继承建立is-a关系,支持多态但耦合度高;组合建立has-a关系,降低耦合度且更灵活。设计时应优先考虑组合,但在需要实现多态时必须使用继承。理解这些特性有助于根据具体场景选择合适的代码复用方式,平衡灵活性

2302_80761497的博客 1018

老版QQ原生表情gif动态

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

【C++:继承】C++面向对象继承全面解析:派生类构造、多继承、菱形虚拟继承与设计模式实践

​​。

艾莉丝努力练剑的博客,感谢大家一直以来的对艾莉丝的支持和鼓励,uu们如果对C/C++方向感兴趣的话,可以通过艾莉丝主页的微信名片加艾莉丝的好友,和努力练剑的艾莉丝一起加油! 1894

《C++ 继承》三大面向对象编程——继承:派生类构造、多继承、菱形虚拟继承概要

本文深入探讨了C++继承机制的核心概念与应用场景。主要内容包括:1)派生类默认成员函数的实现方式,特别是final关键字创建不可继承类;2)继承体系中的友元关系特性,需在派生类中重新声明友元;3)静态成员在继承中的共享机制;4)单继承与多继承的对比,重点分析菱形继承问题及其虚拟继承解决方案;5)继承与组合设计模式的优劣比较,强调"优先使用组合"原则。文章通过大量代码示例演示了继承的实际应用,并指出继承是连接通用类与专用类的重要桥梁,既能实现代码复用又能扩展功能。最后预告了多态相关的内容将

心向往之,行必能至 1856

Python-类-面向对象-继承-多继承-学习笔记

类, 面向对象,继承,多继承

黄裳博客 332

【C++庖丁解牛】面向对象的三大特性之一多态 | 抽象类 | 多态的原理 | 单继承和多继承关系中的虚函数表

需要声明的,本节课件中的代码及解释都是在vs2013下的x86程序中,涉及的指针都是4bytes。如果要其他平台下,部分代码需要改动。比如:如果是x64程序,则需要考虑指针是8bytes问题等等多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。比如Student继承了Person。Person对象买票全价,Student对象买票半价。必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写。

RO-BERRY 1253

【AI_Python基础_08类和对象】

Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基本特征。用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。类中定义的函数。类变量在整个实例化的对象中是公用的。

hhdnioh的博客 2211

python中多继承C3算法研究

在python的面向对象继承问题中,单继承简单易懂,全部接受传承类的属性,并可添加自带属性, 但是,在多继承情况下,会遇到多个被继承者的顺序问题,以及多次继承后查找前几次继承者需求属性时,可能不易发现 99%的多继承可以通过肉眼推测被继承者路径,逐级返回查找需求,但是又有一部分因为继承次数多,被继承几经转折,而不好区分,易被误导, 在这时,可以使用C3算法分析,目前心得记录下,以后...

Jlj977846706的博客 227

面向对象:理解 Python 类的单继承与多继承_单继承和私有对象python

不同种类有不同的天性。而在程序员的思维中,再延伸一下,比如Python是面向对象编程语言。有List、Str、Dict、Tuple等数据类型,这些数据类型也是对象,比如List类可以有count方法,我们可以通过count方法统计列表中各个元素的数量。我们可以简单的将定义类理解成就是定义数据结构,同时给这种数据结构制定一些独特的属性或者方法。我们先看最简单的类,在这里我们定义了Point类调用类之前我们要实例化,这个可以理解成神笔马良画的画,如果不将其搞活,永远是画。通过实例化,调用实例,画中对象就活了。

2401_84562143的博客 374

python3多继承顺序_Python多继承顺序实例分析

本文实例讲述了python多继承顺序。分享给大家供大家参考,具体如下:示例1: #-*- coding:utf-8 -*-#!python2class A(object):def caller(self):print 'A caller'self.called()def called(self):print 'A called'class B(object):def called(self):pr...

weixin_39554775的博客 256

【C++哲学】面向对象的三大特性之 继承

本文系统讲解了C++继承机制的核心概念与应用以及一些细节的考点。文章通过类图示例和代码演示,详细剖析了继承体系中的关键技术和设计原则,为面向对象编程提供了实践指导。

Miun123的博客 1872

c++虚指针及相应对象的数据结构

C++虚函数、多继承和虚基类学习心得   前段时间一直在学习C++中对象的内存布局,由于C++中支持多继承和虚继承,使得对象的内存布局可能变得有些复杂,刚开始去学习时会有点摸不着头脑。另外不同的编译器很可能有着不同的内存布局,进一步加大了学习难度。 网上已经有很

一地鸡毛 787
上一篇: CListCtrl 操作
下一篇: Google Treasure Hunt 2008
UU_Yang
博客等级 码龄23年 926粉丝 213原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值