C++对象继承

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

windows下，vs2017
C++代码：
1、类中没有虚函数：

class Base
{
public:
    int x=1;
    int b=2;
    Base()
    {
        x = 3;
        b = 4;
    }
    void b_test1()
    {
        printf("b_test1\n");
    }
};

class Sub:Base
{
public:
    int x=10;
    int b=11;
    int c=12;
    Sub()
    {
        x = 21;
        b = 22;
        c = 23;
    }
    void b_test1()
    {
        printf("sub_test1\n");
    }
};

int main()
{
    Sub sub;
    return 0;
}

反汇编代码：

    Sub sub;
00BC1818 8D 4D E4             lea         ecx,[sub]            //sub变量地址传给ecx
00BC181B E8 CB F8 FF FF       call        Sub::Sub (0BC10EBh)  

Sub::Sub:
00BC10EB E9 60 06 00 00       jmp         Sub::Sub (0BC1750h) 

    Sub()
00BC1750 55                   push        ebp  
00BC1751 8B EC                mov         ebp,esp  
00BC1753 81 EC CC 00 00 00    sub         esp,0CCh         //分配栈空间
00BC1759 53                   push        ebx  
00BC175A 56                   push        esi  
00BC175B 57                   push        edi  
00BC175C 51                   push        ecx              //把sub地址压栈
00BC175D 8D BD 34 FF FF FF    lea         edi,[ebp-0CCh]   
00BC1763 B9 33 00 00 00       mov         ecx,33h  
00BC1768 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00BC176D F3 AB                rep stos    dword ptr es:[edi]  //栈空间数据初始化
00BC176F 59                   pop         ecx                 //sub地址出栈
00BC1770 89 4D F8             mov         dword ptr [this],ecx  //把sub地址付给this指针。
00BC1773 8B 4D F8             mov         ecx,dword ptr [this]  //this指针传给ecx
00BC1776 E8 B7 F8 FF FF       call        Base::Base (0BC1032h) //调用基类的构造函数

Base::Base:
00BC1032 E9 A9 06 00 00       jmp         Base::Base (0BC16E0h) 

    Base()
00BC16E0 55                   push        ebp  
00BC16E1 8B EC                mov         ebp,esp  
00BC16E3 81 EC CC 00 00 00    sub         esp,0CCh  
00BC16E9 53                   push        ebx  
00BC16EA 56                   push        esi  
00BC16EB 57                   push        edi  
00BC16EC 51                   push        ecx  
00BC16ED 8D BD 34 FF FF FF    lea         edi,[ebp-0CCh]  
00BC16F3 B9 33 00 00 00       mov         ecx,33h  
00BC16F8 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00BC16FD F3 AB                rep stos    dword ptr es:[edi]  
00BC16FF 59                   pop         ecx                   //子类this指针出栈,存放到ecx中
00BC1700 89 4D F8             mov         dword ptr [this],ecx  //将子类的this指针赋给基类的this指针。

class Base
{
public:
    int x=1;
00BC1703 8B 45 F8             mov         eax,dword ptr [this]    
00BC1706 C7 00 01 00 00 00    mov         dword ptr [eax],1     类成员数据初始化
    int b=2;
00BC170C 8B 45 F8             mov         eax,dword ptr [this]  
00BC170F C7 40 04 02 00 00 00 mov         dword ptr [eax+4],2  
    {
        x = 3;
00BC1716 8B 45 F8             mov         eax,dword ptr [this]    //基类构造函数，修改成员变量的值。
00BC1719 C7 00 03 00 00 00    mov         dword ptr [eax],3  
        b = 4;
00BC171F 8B 45 F8             mov         eax,dword ptr [this]  
00BC1722 C7 40 04 04 00 00 00 mov         dword ptr [eax+4],4  

    }
00BC1729 8B 45 F8             mov         eax,dword ptr [this]  
00BC172C 5F                   pop         edi  
00BC172D 5E                   pop         esi  
00BC172E 5B                   pop         ebx  
00BC172F 8B E5                mov         esp,ebp  
00BC1731 5D                   pop         ebp  
00BC1732 C3                   ret  

class Sub:Base
{
public:
    int x=10;
00BC177B 8B 45 F8             mov         eax,dword ptr [this]  
00BC177E C7 40 08 0A 00 00 00 mov         dword ptr [eax+8],0Ah //子类成员变量初始化，注意成员变量的地址
    int b=11;
00BC1785 8B 45 F8             mov         eax,dword ptr [this]  
00BC1788 C7 40 0C 0B 00 00 00 mov         dword ptr [eax+0Ch],0Bh  
    int c=12;
00BC178F 8B 45 F8             mov         eax,dword ptr [this]  
00BC1792 C7 40 10 0C 00 00 00 mov         dword ptr [eax+10h],0Ch  
    {
        x = 21;
00BC1799 8B 45 F8             mov         eax,dword ptr [this]  
00BC179C C7 40 08 15 00 00 00 mov         dword ptr [eax+8],15h //子类构造函数修改子类成员变量的值。 
        b = 22;
00BC17A3 8B 45 F8             mov         eax,dword ptr [this]  
00BC17A6 C7 40 0C 16 00 00 00 mov         dword ptr [eax+0Ch],16h  
        c = 23;
00BC17AD 8B 45 F8             mov         eax,dword ptr [this]  
00BC17B0 C7 40 10 17 00 00 00 mov         dword ptr [eax+10h],17h  
    }
00BC17B7 8B 45 F8             mov         eax,dword ptr [this]  
00BC17BA 5F                   pop         edi  
00BC17BB 5E                   pop         esi  
00BC17BC 5B                   pop         ebx  
00BC17BD 81 C4 CC 00 00 00    add         esp,0CCh  
00BC17C3 3B EC                cmp         ebp,esp  
00BC17C5 E8 5D F9 FF FF       call        __RTC_CheckEsp (0BC1127h)  
00BC17CA 8B E5                mov         esp,ebp  
00BC17CC 5D                   pop         ebp  
00BC17CD C3                   ret 

    return 0;
00BC1820 33 C0                xor         eax,eax  
}

2、类中包含虚函数：

class Base
{
public:
    int x=1;
    int b=2;
    Base()
    {
        x = 3;
        b = 4;
    }
    virtual void b_test1()
    {
        printf("b_test1\n");
    }
};

class Sub:Base
{
public:
    int x=10;
    int b=11;
    int c=12;
    Sub()
    {
        x = 21;
        b = 22;
        c = 23;
    }
    virtual  void b_test1()
    {
        printf("sub_test1\n");
    }
};


int main()
{
    Sub sub;
    return 0;
}

反汇编：

int main()
{
01041A30 55                   push        ebp  
01041A31 8B EC                mov         ebp,esp  
01041A33 81 EC E4 00 00 00    sub         esp,0E4h  
01041A39 53                   push        ebx  
01041A3A 56                   push        esi  
01041A3B 57                   push        edi  
01041A3C 8D BD 1C FF FF FF    lea         edi,[ebp-0E4h]  
01041A42 B9 39 00 00 00       mov         ecx,39h  
01041A47 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
01041A4C F3 AB                rep stos    dword ptr es:[edi]  
01041A4E A1 00 A0 04 01       mov         eax,dword ptr [__security_cookie (0104A000h)]  
01041A53 33 C5                xor         eax,ebp  
01041A55 89 45 FC             mov         dword ptr [ebp-4],eax  
    Sub sub;
01041A58 8D 4D E0             lea         ecx,[sub]                     
01041A5B E8 A9 F6 FF FF       call        Sub::Sub (01041109h)     //断点到此处：
    return 0;
01041A60 33 C0                xor         eax,eax  
}

Sub::Sub:
01041109 E9 F2 06 00 00       jmp         Sub::Sub (01041800h) 

    Sub()
01041800 55                   push        ebp  
01041801 8B EC                mov         ebp,esp  
01041803 81 EC CC 00 00 00    sub         esp,0CCh  
01041809 53                   push        ebx  
0104180A 56                   push        esi  
0104180B 57                   push        edi  
0104180C 51                   push        ecx  
0104180D 8D BD 34 FF FF FF    lea         edi,[ebp-0CCh]  
01041813 B9 33 00 00 00       mov         ecx,33h  
01041818 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
0104181D F3 AB                rep stos    dword ptr es:[edi]  
0104181F 59                   pop         ecx  
01041820 89 4D F8             mov         dword ptr [this],ecx  
01041823 8B 4D F8             mov         ecx,dword ptr [this]  
01041826 E8 0C F8 FF FF       call        Base::Base (01041037h)

Base::Base:
01041037 E9 44 07 00 00       jmp         Base::Base (01041780h) 

    Base()
01041780 55                   push        ebp  
01041781 8B EC                mov         ebp,esp  
01041783 81 EC CC 00 00 00    sub         esp,0CCh  
01041789 53                   push        ebx  
0104178A 56                   push        esi  
0104178B 57                   push        edi  
0104178C 51                   push        ecx  
0104178D 8D BD 34 FF FF FF    lea         edi,[ebp-0CCh]  
01041793 B9 33 00 00 00       mov         ecx,33h  
01041798 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
0104179D F3 AB                rep stos    dword ptr es:[edi]  
0104179F 59                   pop         ecx  
010417A0 89 4D F8             mov         dword ptr [this],ecx  
010417A3 8B 45 F8             mov         eax,dword ptr [this]  
010417A6 C7 00 34 7B 04 01    mov         dword ptr [eax],offset Base::`vftable' (01047B34h) 
//注意此处的不同，没有虚函数的话，[eax]是基类第一个成员的地址，有虚函数存在，此处存放的是该类的虚函数表的地址。

class Base
{
public:
    int x=1;
010417AC 8B 45 F8             mov         eax,dword ptr [this]  
010417AF C7 40 04 01 00 00 00 mov         dword ptr [eax+4],1   //基类的第一个成员地址为[eax+4]
    int b=2;
010417B6 8B 45 F8             mov         eax,dword ptr [this]  
010417B9 C7 40 08 02 00 00 00 mov         dword ptr [eax+8],2  
    {
        x = 3;
010417C0 8B 45 F8             mov         eax,dword ptr [this]  
010417C3 C7 40 04 03 00 00 00 mov         dword ptr [eax+4],3  
        b = 4;
010417CA 8B 45 F8             mov         eax,dword ptr [this]  
010417CD C7 40 08 04 00 00 00 mov         dword ptr [eax+8],4  
    }
010417D4 8B 45 F8             mov         eax,dword ptr [this]  
010417D7 5F                   pop         edi  
010417D8 5E                   pop         esi  
010417D9 5B                   pop         ebx  
010417DA 8B E5                mov         esp,ebp  
    }
010417DC 5D                   pop         ebp  
010417DD C3                   ret  

0104182B 8B 45 F8             mov         eax,dword ptr [this]  
0104182E C7 00 4C 7B 04 01    mov         dword ptr [eax],offset Sub::`vftable' (01047B4Ch)
//将子类的虚表地址修改成该类的虚表地址。

class Sub:Base
{
public:
    int x=10;
01041834 8B 45 F8             mov         eax,dword ptr [this]  
01041837 C7 40 0C 0A 00 00 00 mov         dword ptr [eax+0Ch],0Ah //子类成员变量初始化，在基类成员下面。
    int b=11;
0104183E 8B 45 F8             mov         eax,dword ptr [this]  
01041841 C7 40 10 0B 00 00 00 mov         dword ptr [eax+10h],0Bh  
    int c=12;
01041848 8B 45 F8             mov         eax,dword ptr [this]  
0104184B C7 40 14 0C 00 00 00 mov         dword ptr [eax+14h],0Ch  
    {
        x = 21;
01041852 8B 45 F8             mov         eax,dword ptr [this]  
01041855 C7 40 0C 15 00 00 00 mov         dword ptr [eax+0Ch],15h  
        b = 22;
0104185C 8B 45 F8             mov         eax,dword ptr [this]  
0104185F C7 40 10 16 00 00 00 mov         dword ptr [eax+10h],16h  
        c = 23;
01041866 8B 45 F8             mov         eax,dword ptr [this]  
01041869 C7 40 14 17 00 00 00 mov         dword ptr [eax+14h],17h  
    }
01041870 8B 45 F8             mov         eax,dword ptr [this]  
01041873 5F                   pop         edi  
01041874 5E                   pop         esi  
01041875 5B                   pop         ebx  
01041876 81 C4 CC 00 00 00    add         esp,0CCh  
0104187C 3B EC                cmp         ebp,esp  
0104187E E8 C2 F8 FF FF       call        __RTC_CheckEsp (01041145h)  
01041883 8B E5                mov         esp,ebp  
01041885 5D                   pop         ebp  
01041886 C3                   ret  

    return 0;
01041A60 33 C0                xor         eax,eax
rznice
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++三大特性—继承 “基类与派生类之间的类型转换与赋值转换”
DEXTERFUTIAN的博客
04-29 2414
理解基类与派生类之间的类型转换是理解C++语言面向对象编程的关键所在。 理解静态类型与动态类型、不存在基类向派生类的隐式类型转换、以及对象之间不存在类型转换
C++编程基础——继承、对象类型转换、虚函数、多态
琛翀的风暴空间
03-30 803
对象类型转换 向上转型：子类类型转化为父类类型，有意义、安全、可以隐式进行。 向下转型：从父类类型转化为子类类型，不一定有意义、也不一定安全、必须由我们自己进行强制类型转换。 mutable关键字：异变的、可变的，该关键字修饰的变量总能被修改，不受 const 关键字的影响。 虚函数（Virtual Function） 用 virtual 关键字修饰的方法就是虚函数（虚方法） 当用一个父类指针或引用指向某个子类对象时，通过这个指针或引用调用父类中的某个虚函数，如果子类重写（Override）了父类中的这个虚
c++ 面向对象之继承详解
最新发布
zhhg0123的博客
04-09 533
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。”-——百度百科。当然，没有必要你现在就理解这句话！继承大意就是说一个类，在另一个类的基础上拥有其他功能。比如人有姓名、年龄、国籍等信息，而学生继承人的特性，还具有学号、老师、学校等信息。
C++ 对象间的继承关系(赋值兼容规则)
qq_63282188的博客
06-11 1347
C++ 通过类派生 的机制来支持继承。被继承的类称为基类 ，新产生的类为派生类 或子类，基类和派生类的集合 称作类继承层次结构。
【C++】面向对象---继承(万字详解)
Lin5200000的博客
01-15 1947
一篇文章让你深入C++的继承体系
C++继承中，支持从下到上的转换
KingOfMyHeart的博客
04-17 673
实例 继承中支持的是从下到上的转换。 比如有个基类叫职业类， class Occupation; class Occupation { public: Occupation(); virtual ~Occupation(); }; 然后可以派生出学生类，老师类，程序员类等, 如class Student; class Student ： public Occupation { public: Student(); ~Student(); }; 我们可以将派生类对象赋值给一个基类对象，换言之，学生
关于C++对象继承中的内存布局示例详解
12-25
本文给大家介绍的是关于C++对象继承的内存布局的相关内容，分享出来供大家参考学习，在开始之前说明下，关于单继承和多继承的简单概念可参考此文章 以下编译环境均为：WIN32+VS2015 虚函数表 对C++ 了解的人都应该...
c++面向对象实现继承car
07-17
c++面向对象实现继承car
C++继承介绍
09-05
在C++编程语言中，继承是一种面向对象编程的特性，它允许一个类（子类或派生类）从另一个类（基类或父类）继承属性和行为。这有助于实现代码重用，使得子类可以扩展或修改父类的功能，同时保持与父类的兼容性。C++...
【千律】C++基础：父类对象和子类对象之间的相互转换
weixin_42704093的博客
04-01 1430
#include <iostream> using namespace std; // 枚举类型：用于判断子类类型 enum RoomType { Type_ErrorRoom = 0, Type_Star_Room = 1, Type_TrvalRoom = 2 }; // 定义父类 class Hotels { public: int type; int price; char* name; // 构造函数 Hotels(const char* t_name, .
C++面向对象之继承
m0_63520910的博客
08-23 390
从基类继承过过来的表现其共性，而新增的成员体现了其个性。class 子类 ： 继承方式 父类。一类是从基类继承过来的，一类是自己增加的成员。继承是面向对象三大特性之一。继承的好处：减少重复代码。
C++的protected
图像学习之旅
02-01 3307
基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。 也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。 2) 不管继承方式如何，基类中的 privat
C++面向对象的继承机制
weixin_40630836的博客
06-30 852
C++继承■  继承：在已有类的基础上创建新类的过程面向对象程序设计中最重要的一个概念是继承。 当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。一个 B 类继承A类，或称从类 A 派生类 B。 类 A 称为基类（父类），类 B 称为派生类（子类）类继承关系的语法形式：class 派生类名 : 基类名表 ...
C++ 类(继承中的构造和析构)
小白的博客
07-29 1万+
文章概述 类型(赋值)兼容性原则; 类型(赋值)兼容性原则可以分为2个情况; 继承中的对象模型(内存模型); 继承中的构造析构调用原则; 继承和组合混搭下的构造和析构; 继承中同名的成员函数和成员变量处理方法; 继承中的static关键字 类型(赋值)兼容性原则 a. 类型(赋值)兼容性原则的说明: 需要基类对象的任何地方,都可以用公有派生类对象代替。通过公有继承,派生类得到了基类中...
c++类和对象---继承
m0_50046535的博客
04-15 644
继承是面向对象三大特性之一 1、继承的基本语法 语法： class 子类名 ：继承方式 父类名 子类 也叫 派生类 父类 也叫 基类 class basepage { public: void header() { cout << "首页，公开课、登录、注册..." << endl; } void footer() { cout << "帮助、交流、地图..." << endl; } void left() { cou
C++中的继承
热门推荐
studyhardi的博客
06-02 4万+
1.为什么要使用继承 继承性是一个非常自然的概念，现实世界中的许多事物都是具有继承性的。人们一般用层次分类的方法来描述他们的关系。例如，下图就是一个简单的汽车分类图： 在这个分类树中建立了一个层次结构，最高一层是最普遍、最一般的，每一层都比它的前一层更具体，低层具有高层的特性，同时也有与高层的细微不同。例如，确定了一辆车是客车以后，没有必要再指出它可以进行运输，因为客车本身就是从运输汽车类中派生...
C++虚继承对象模型
xsh_123321的专栏
10-21 4137
1.为什么需要虚继承如下图所示如果访问Der::Fun or Der::m_nValue就会带来二义性，无法确定是调用Base1的还是Base2的，所以为了解决多重继承情况下成员访问的二义性，引入了虚继承机制。一般继承                                                                           虚继承2.虚继承实现在虚继承下，Der通过共享虚基类SuperBase来避免二义性，在Base1，Base2中分别保存虚基类指针，Der继承Ba
c++ 的继承
tutb12345的专栏
08-08 413
<br />通过继承机制，可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。<br />　　在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。从一个基类派生的继承称为单继承；从多个基类派生的继承称为多继承。<br />　　派生类的定义格式<br />　　单继承的定义格式如下：<br />　class <派生类名>:<继承方式><基类名>
C++-----对象的继承（一）
Allen_Xu17
12-27 110
#include "stdafx.h" #include &lt;iostream&gt; using namespace std; //继承： //减少代码的重复性； //网页实例： class news { public: void head() { cout &lt;&lt; "公共的头部" &lt;&lt; endl; } void footer() { cout...
c++多继承 子类对象类型转换
09-06
C++中的多继承是指一个子类可以从多个父类继承属性和行为。子类可以通过类型转换将自身对象转换为其中一个父类类型的对象。 子类对象类型转换是通过将子类对象指针或引用赋值给父类指针或引用来实现的。这种类型转换可以使得子类对象可以被当作父类对象来使用，调用父类中定义的成员函数或访问父类中的成员变量。 例如，假设有一个类A和类B，类B继承自类A，我们可以创建一个类B的对象b，然后将b转换为类A的对象，即类A的指针或引用指向b。这样就可以通过使用类A的指针或引用来访问类A中定义的成员函数或变量。 多继承子类对象类型转换的一个应用场景是在面向对象的程序设计中，以实现多态性。多态性是指同一操作作用在不同的对象上会有不同的行为。通过将子类对象转换为父类对象，可以在程序中使用同一个指针或引用来处理不同类型的对象，从而实现多态性的效果。 需要注意的是，在进行子类对象类型转换时，需要确保所转换的对象是多继承关系中其中一个父类的子类对象，否则可能导致类型不匹配的错误或未定义的行为。此外，多继承会增加程序的复杂性，因此在设计和使用时需要谨慎考虑。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值