C++继承和多态

已于 2022-11-11 10:25:39 修改
阅读量2.9k 收藏 10
点赞数 4
CC 4.0 BY-SA版权
分类专栏： coding 文章标签： c++ 开发语言
于 2022-05-05 22:15:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39861267/article/details/124594633

文章目录

一、继承的功能

  1. 代码复用；
  2. 在基类中提供统一的虚函数接口，让派生类进行重写，然后就可以使用多态了。

 

二、继承的本质

派生类可以将基类的所有成员都继承过来，等于说，在派生类的内存空间中也存在了一份基类的成员变量，只不过这些变量都是带作用域的，如下图所示：
在这里插入图片描述

class A {
    int ma;
};

class B : A {
    int mb;
};

class C : B {
    int mc;
};

int main() {
    A a;
    B b;
    C c;
    cout << sizeof(a) << endl;		//4
    cout << sizeof(b) << endl;		//8
    cout << sizeof(c) << endl;		//12
    return 0;
};

 

三、继承方式

public，protected，private

  • 继承方式是继承下来的成员在类外访问权限的上限；
  • 多重继承下，派生类的继承方式看直接继承的基类；
  • 外部只能访问对象public成员，protected和private的成员无法直接访问。
  • 在继承结构中，派生类从基类可以继承过来private成员，但是派生类却无法直接访问
  • 默认的继承方式：class定义派生类，默认继承方式是private；struct定义派生类默认继承方式是public

 

四、派生类的实例化过程

  • 派生类无法直接初始化从基类继承来的变量，而只能通过基类的构造函数来初始化
class Base {
public:
    Base(int data = 10) : ma(data) {}

    int ma;
};

class Derive : public Base {
public:
//  Derive(int data = 10) : ma(), mb(data) {}   //会报错，无法直接对继承来的成员进行初始化

    Derive(int data = 10) : Base(data), mb(data) {} //必须使用基本的构造函数进行初始化

    int mb;
};
  • 派生类实例化的时候会先调用基类的构造函数初始化从基类继承来的成员，派生类实例消亡的时候会先将派生类实例销毁（使用派生类析构函数释放资源），再销毁基类实例（使用基类析构函数释放资源）。

 

五、重载、隐藏、覆盖

  1. 重载：一组函数在同一个作用域下，函数名相同，参数列表不同，构成重载关系。
  2. 隐藏：在继承结构当中（即不同作用域），派生类的同名成员把基类的同名成员隐藏起来了。
  3. 覆盖：虚函数表中，派生类虚函数地址覆盖基类虚函数地址
class Base {
public:
    Base(int data = 10) : ma(data) { cout << __FUNCTION__ << endl; }

    ~Base() { cout << __FUNCTION__ << endl; }

    void show() { cout << this << endl; }    //1号函数

    void show(int a) { cout << a << endl; } //2号函数

    int ma;
};

class Derive : public Base {
public:
    Derive(int data = 10) : mb(data) { cout << __FUNCTION__ << endl; }

    void show() { cout << __FUNCTION__ << endl; }  //3号函数

    ~Derive() { cout << __FUNCTION__ << endl; }

    int mb;
};

int main() {
    Derive b(10);
//  b.show(100);    //报错因为带int参数的show函数被隐藏了
    b.Base::show(100);	//如果要调用上述函数，需要加作用域
    system("pause");
    return 0;
};

1号函数和2号函数是重载关系
3号函数隐藏了1号函数和2号函数，所以，如果构造了Derive的对象，并调用show(int a)函数会出错，因为现在Derive对象只能看到自己的show()函数。
 

六、基类对象和派生类对象的转换

继承结构是一种从上（基类）向下（派生类）的结构

  • 派生类对象赋值给一个基类对象，类型从下到上的转换；
  • 基类对象不能赋值给派生类对象；
  • 基类指针可以指向派生类对象，类型从下到上的转换，但是该指针只能访问到基类囊括的成员；
  • 派生类指针不能指向基类对象。

总结来说，派生类是基类，基类不是派生类，类似于，白马是马，马不是白马。
 

七、虚函数，静态绑定和动态绑定

  • 一个类里如果定义了虚函数，编译时期，编译器就会为该类生成唯一的虚函数表vftable，虚函数表中存储的信息如下。程序运行时，每一张虚函数表都会加载到内存的.rodata区。
  • 一个类中如果定义了虚函数，那个这个类的对象，运行时，内存中开始的部分，会多存储一个vfptr虚函数指针，指向相应函数的虚函数表vftable，一个类型定义的n个对象指向的是同一个虚函数表。
  • 一个类中的虚函数个数，不影响对象的内存大小，影响的只是虚函数表的大小。
  • 如果派生类中的方法，和基类继承来的某个方法，返回值、函数名、参数列表都相同，而且基类的方法是虚函数，那么这个派生类的方法会被自动处理成虚函数。
  • 编译器处理派生类虚函数表的时候会先把基类虚函数表中的虚函数都继承下来，然后如果派生类中有和基类中相同的虚函数，就用派生类中的虚函数覆盖/重写基类的虚函数。

在这里插入图片描述

静态绑定（编译时期的绑定）：编译器在编译时期根据对象的类型调用相应作用域下的成员函数，如果该成员函数是非虚函数，就直接调用该类型作用域下的函数生成指令。
动态绑定（运行时期的绑定）：编译器在编译时期根据对象的类型调用相应作用域下的成员函数，如果该成员函数是虚函数，就在运行期间调用实际对象的虚函数表中对应的虚函数。
 
注意：

  1. 使用对象调用某个方法的时候只会发生静态绑定，因为已经有了对象，调用哪个作用域中的方法已经很明确了。
  2. 使用指针或者引用调用虚函数的时候才会发生动态绑定
  3. 构造函数中调用的虚函数并不会发生动态绑定

 

八、多继承下的对象内存分布

class Derive: public Base1, public Base2

在这里插入图片描述
注意：vfptr是在对象构造函数运行之前就写入对象内存的
 

九、虚析构函数（消失的析构函数）

class Base {
public:
    Base() { cout << __FUNCTION__ << endl; }

    ~Base() { cout << __FUNCTION__ << endl; }
};

class Derive : public Base {
public:
    Derive() { cout << __FUNCTION__ << endl; }

    ~Derive() { cout << __FUNCTION__ << endl; }

};


int main() {
    Base *pb = new Derive;
    delete pb;
    return 0;
};

以上程序输出如下：

Base
Derive
~Base

问题：~Derive析构函数并没有调用，这样会导致内存泄漏

问题产生原因：delete pb运行时，会去调用pb指针类型（Base类）的析构函数，编译器发现Base类的析构函数不是virtual，于是发生静态绑定，直接调用Base类的析构函数，而不会调用Derive的析构函数

解决办法：将基类析构函数~Base声明成virtual ~Base()，如此操作之后输出如下：

Base
Derive
~Derive
~Base

 

  • 虚函数依赖：
    虚函数要能产生地址，存储在vftable中；
    对象必须存在，这样才能依据对象中的虚函数表指针寻找函数（vfptr----> vftable ---->虚函数）；
     
  • 构造函数不能是virtual，因为构造函数调用完成之后才有对象
    构造函数中调用的任何函数（虚函数或非虚函数）都是静态绑定；
     
  • virtual 和static不能共存，因为static函数并不依赖于对象；
     
  • 把基类的析构函数实现成虚函数的时机：
    基类的指针（引用）指向堆上new出来的派生类对象时。
     

十、多态（多种多样的形态）

静态（编译时期）多态：

  • 函数重载，在编译阶段就确定好要调用的函数版本；
  • 函数模板，在编译时期使用具体的类型对函数模板进行实例化。

动态（运行时期）多态：

  • 在继承结构中，基类指针（引用）指向派生类对象，通过该指针（引用）调用同名覆盖方法（虚函数），基类指针指向哪个派生类对象，就会调用哪个派生类对象的覆盖方法，称为多态。多态是通过动态绑定来实现的。
     

十一、抽象类

class Animal {
public:
    virtual void bark() = 0;  //纯虚函数，Animal类成为抽象类，纯虚函数必须被派生类重写
};

 

十二、虚继承和虚基类

 
虚继承的时候派生类对象的内存分布如下:
在这里插入图片描述

如图所示，虚继承的时候，基类的内容会被移到派生类对象内存区域的最后。(以上只是msvc中的对象内存结构，在gcc中，内存结构并没有发生后移的现象)
 

基类指针指向派生类对象的时候，指针指向的永远是派生类对象中基类内容的开始部分

class Base {
public :

    virtual void func() { cout << "Base::func" << endl; }

    void operator delete(void *p) {
        cout << "operate delete p:" << p << endl;
        free(p);
    }
};

class Derive : virtual public Base {
public :
    void func() { cout << "Derive::func" << endl; }

    void *operator new(size_t size) {
        void *p = malloc(size);
        cout << "operate new p:" << p << endl;
        return p;
    }
};


int main() {
    Base *pb = new Derive();
    cout << "main p:" << pb << endl;
    pb->func();
    delete pb;    //msvc编译器和gcc编译器在处理此处处理有所不同
    system("pause");
    return 0;
};

如上代码所示在delete pb的时候会出现问题，由于pb指向的并不是Derive对象的内存起始位置，而是Derive对象中从基类继承来的内容的起始部分，所以delete的时候会出错，gcc编译器会自动处理上述问题，而msvc会报错。
 

十三、多重继承的问题

菱形继承和圆形继承如下图所示
在这里插入图片描述
以上继承方式，最后的派生类会重复继承到最初基类的成员。
 
解决办法：将最初基类继承的方式变成虚继承。
因为虚继承的时候会把基类的内存转移到派生类对象最后，然后覆盖掉基类重复的变量。

C++：继承和多态
guoziqing506的博客
07-10 1817
C++中类之间的关系，一共分为以下三种： has-a：包含关系。表示类A的一个成员是类B，比如类Student中，有数据成员score，而score是属于类Score的； use-a：使用关系。表示类B会用到类A的成员，比如类State会用到类Region中的成员函数getArea()，我们可以通过定义友元类来实现快捷编程； is-a：继承关系。表示类B是类A的一个子集，比如类Student是...
C++——继承和多态
weixin_57133901的博客
03-07 2536
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
C++中的继承与多态
最新发布
m0_73987904的博客
05-10 1778
本文深入探讨了C++中的类继承机制，解释了继承的基本概念、语法格式及其在工程中的应用。文章详细介绍了类继承的三种方式（public、protected、private）及其对访问权限的影响，强调了public继承的广泛适用性。此外，文章还讨论了基类与派生类之间的赋值兼容性、内存切片现象以及继承中的作用域问题。通过示例代码和图示，文章展示了继承中可能出现的特殊现象，如隐藏和覆盖，并提供了实际代码运行结果以加深理解。最后，文章总结了继承在C++编程中的重要性，强调了其在扩展类功能和提高代码复用性方面的优势。
C++ 继承和多态
凡事都是靠练习
08-17 3122
讲解继承和多态，多态的实现原理
C语言实现C++继承和多态的代码分享
08-29
C语言实现C++继承和多态的代码分享 本文主要讲诉了C和C++的区别，以及如何使用C语言模拟实现C++继承和多态，并附上示例代码。下面是相关知识点的总结： 1. C语言和C++的区别： * C语言是面向过程的语言，而C++是...
C语言模式实现C++继承和多态的实例代码
08-29
然而，借助一些编程技巧，我们可以在C语言中模拟C++的继承和多态机制。这不仅可以增强C语言的功能，还能让习惯了面向对象思维的程序员在使用C语言时更加得心应手。本文将通过具体的实例代码来展示如何在C语言中实现...
C++继承与多态
m0_62656812的博客
12-16 615
C++是一款面向对象的语言，对象是可以物化的实体，拥有自己的特性与行为，像车子有外形，内核，可以加速减速。而车子又分为保时捷与宝马、奔驰等等。我们想要描述一个车子对象的特征，就需要创建一个类，若为每一种车创建一个类，会使效率下降，而不同车子之间既有共性又有特性，因此，便产生了派生类。 一、派生类的继承方式 派生类（子类）继承了基类（父类）的特性，同时它可以添加自己的诸多特点。继承的方式有以下三种 既：派生类对基类的继承小于等于基类的数据（包括成员变量与成员函数） 无论...
【C++】继承与多态
Pursue quality, not quantity.
03-01 2088
C++继承与多态万字详解！！
C++ 继承与多态
XXXTENTAC1ON的博客
03-23 2581
继承与多态介绍继承的概念与定义 介绍 继承机制 是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员保持原有类特性的基础上进行扩展，增加功能；这样产生新的类，称派生类；继承呈现了面向对象程序设计的层次结构；体现了由简单到复杂的认识过程 多态性 是考虑在不同层次的类中，以及在统一类中，统么的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性；以虚基类为基础的运行时的多态性是面向对象程序设计的标志性特征；体现了类推和比喻的思想方法 早期绑定：编译时就确定了调用关系 晚绑定：程序运行的过
C++ ——继承和多态
Li27的博客
08-20 762
继承&多态两大特性的初步实现机制；抓住对实体的抽象，多层抽象，定义出丰富的类！
c++继承与多态
转行笔记
08-30 1155
c++继承与多态
C++ 继承 多态
小楠树
05-16 574
继承和派生 面向对象的语言有三种特性封装，继承和多态。 C++的1可重用性是通过继承这一机制来实现的。 继承的基本概念 继承是类之间定义的一种重要关系 一个B类继承A类，或称从A类派生B类 类A称为基类（父类），类B称为派生类（子类） 见如下代码： class A { public: func() { } in...
C++ 继承&多态
weixin_33906657的博客
03-19 121
继承&多态· 访问限定符*继承访问控制的作用是将继承下来的成员在派生类域内的属性改变而和原本基类的成员访问控制符关。所有的基类private成员在派生类里是不可见，但它确确实实被继承下来了。基类的protected成员只对继承它的派生类可见，在类外不可使用· 派生类列表 在定义派生类的时候我们必须写出派生类列表，但在声明处不可写。1.虚函数的使用（多态的实现）#...
C++继承 多态
qq_60814870的博客
01-30 990
C++继承 多态
C++继承和多态机制详解
继承和多态 继承是面向对象编程语言中的一种机制，它允许一个类继承另一个类的属性和方法，从而提高程序的可复用性。继承的主要特点是：子类可以继承父类的所有成员变量和成员函数，子类可以对父类的成员变量和成员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值