C++语法基础（D）- 继承、多态

最新推荐文章于 2024-07-20 18:10:49 发布
最新推荐文章于 2024-07-20 18:10:49 发布
阅读量742 收藏 18
点赞数 22
分类专栏： C/C++开发 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42077965/article/details/136020304
版权
本文详细介绍了C++中的继承机制，包括基本语法、不同类型的继承、构造与析构的执行顺序，以及多态的概念、静态/动态联编、抽象类、纯虚函数、虚析构和向上/向下类型转换。通过实例演示了多态在电脑组装场景中的应用。
摘要由CSDN通过智能技术生成

继承、多态

（一）继承和派生

1.基本语法

作用： 利用继承可以减少重复代码
类名： 基类（父类） 派生类（子类）
语法： class 子类 ：继承方式 父类

class BasePage//基类
{
    public:
        void header()
        {
            cout << "公共头部" << endl;
        }
}
class GamePage : public BasePage//派生类
{
    public:
        void content()
        {
            cout << "Game" << endl;
        }
}
class NewsPage : public BasePage
{
    public:
        void content()
        {
            cout << "news" << endl;
        }
}

2.继承方式

继承方式

3.继承中的对象模型

  • 父类中私有属性，子类也继承下去了，但被编译器隐藏，无法访问
  • 可以通过 开发人员命令提示工具（Developer Command Prompt for VS 2019）进行查看对象模型
    • 跳转至对应目录下，输入cl /d1 reportSingleClassLayout类名 文件名
class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
class Son : public Base
{
public:
    int m_D;
};
int main()
{
    cout << sizeof(Son) << endl;//16
}

4.继承中的构造和析构

  • 继承中，先调用父类的构造，后调用子类的构造，析构和构造顺序相反
  • 可以利用初始化列表语法显示指定出调用父类的哪个构造函数
  • 子类不会继承父类中的构造和析构，只有父类自己才知道如何构造和析构自己的属性
class Base
{
public:
    Base(int i) 
    {
        cout << "Base" << i << endl;
    }
    ~Base()
    {
        cout << "~Base" << endl;
    }
};
class Son : public Base
{
public:
    Son(int i) : Base(i)//初始化列表
    {
        cout << "Son" << i << endl;
    }
    ~Son()
    {
        cout << "~Son" << endl;
    }
};

5.继承中同名的成员或静态成员处理

  • 如果子类和父类拥有同名成员，优先调用子类的成员，可以通过作用域调用父类的成员
  • 同名的成员函数，子类会隐藏掉父类中的所有版本，如果想调用父类中的其它版本，加上作用域即可
  • 静态成员和普通成员的处理方式类似，只是静态成员可以通过类名进行访问
class Base
{
public:
    Base()
    {
        this->m_A = 100;
    }
    void func()
    {
        cout << "Base::func" << endl;
    }
    void func(int i)
    {
        cout << "Base::func" << i << endl;
    }
    int m_A;
};
class Son : public Base
{
public:
    Son()
    {
        this->m_A = 200;
    }
    void func()
    {
        cout << "Son::func" << endl;
    }
    int m_A;
};
void test()
{
    Son s;
    cout << s.m_A << endl;//调用Son类中的m_A
    cout << "Base: " << s.Base::m_A << endl;//调用Base类中的m_A

    //同名的成员函数，子类会隐藏掉父类中的所有版本
    s.func(); //调用Son类中的func
    s.Base::func();//调用Base类中的func
}

6.多继承语法

  • class子类：继承方式 父类1，继承方式 父类2
  • 当两个父类中，有同名的成员被子类继承后，调用时需要加作用域进行区分
class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
    int m_A;
};
class Base2
{
public:
    Base2()
    {
        m_A = 200;
    }
    int m_A;
};
class Son : public Base1, public Base2
{
public:
    Son()
    {
        m_C = 300;
    }
    int m_C;
};
void test()
{
    Son s;
    //两个父类中，有同名的成员被子类继承后，调用时需要加作用域进行区分
    cout << s.Base1::m_A << endl;
    cout << s.Base2::m_A << endl;
}

7.菱形继承和虚继承

菱形继承

问题：

  1. 羊继承了动物的数据和函数，驼也继承了动物的数据和函数，当草泥马调用函数或数据时，就会产生二义性
  2. 草泥马继承自动物的函数和数据两份，我们只需要一份，另一份会被浪费

处理：

  • 使用virtual关键字-虚继承
  • 在Sheep和Tuo类中继承的内容为vbptr（虚基类指针）
    • v—virtual
    • b—base
    • ptr—pointer
    • vbptr指向vbtable（虚基类表）
    • vbtable中有偏移量，通过偏移量可以找到唯一的数据

虚继承

class Animal//虚基类
{
public:
    int m_Age;
};
class Sheep : virtual public Animal{};//虚继承
class Tuo : virtual public Animal{};
class SheepTuo : public Sheep, public Tuo{};
void test()
{
    SheepTuo st;
    st.Sheep::m_Age = 100;
    st.Tuo::m_Age = 200;
    cout << st.m_Age << endl;
}

（二）多态

  • 多态性提供了接口与具体实现之间的隔离，从而将“what”和“how”分离开的
  • 多态的好处：对扩展性提高，组织性强，可读性强
    • 如果父类中有了虚函数，子类并没有重写父类的虚函数，那么这样的代码是毫无意义的
    • 如果子类不重写父类虚函数，会没有使用多态带来的好处，并是内部结构更加复杂
  • 代码编写原则：开闭原则（对扩展进行开放，对修改进行关闭）

1.静态联编和动态联编

  • 编译时多态（静态多态）：运算符重载和函数重载

  • 运行时多态（动态多态）：派生类和虚函数

  • 静态多态和动态多态区别：函数地址早绑定（静态联编）还是晚绑定（动态联编）

    • 函数调用，在编译阶段就可以确定函数的调用地址，并产生代码，地址是早绑定
    • 函数调用，不能在编译期间确定，而需要在运行时确定，地址就是晚绑定

  • 对于有父子关系的两个类，C++可以不需要通过类型强转

多态满足的条件

  1. 父类中有虚函数
  2. 子类重写父类的虚函数
  3. （使用）父类的指针或引用指向子对象

重写—virtual虚函数

  1. 子类重新实现父类中的虚函数，必须返回值、函数名、参数一致才称为重写
  2. 子类在做重写时，可以不加关键字virtual
class Animal
{
public:
    virtual void speck()//虚函数
    {
        cout << "动物在说话" << endl;
    }
};
class Cat : public Animal
{
public:
    void speck()//重写
    {
        cout << "小猫在说话" << endl;
    }
};
//对于有父子关系的两个类，C++可以不需要通过类型强转
void DoSpeck(Animal& animal)
{
    animal.speck();
}
int main()
{
    Cat cat;
    DoSpeck(cat);//小猫在说话
}

2.多态原理

  1. 当父类中存在虚函数后，内部发生结构变化，多了虚函数表指针vfptr，指向虚函数表vftable
  2. 虚函数表内部记录着虚函数地址
  3. 当子类发生重写后，会修改子类中的虚函数表中的函数地址，但不会影响父类中的虚函数表

多态原理

  1. 多态的深度分析
class Animal
{
public:
    virtual void speak()
    {
        cout << "Animal Speak" << endl;
    }
    virtual void eat(int i)
    {
        cout << "Animal Eat" << i << endl;
    }
};
class Cat : public Animal
{
public:
    void speak()
    {
        cout << "Cat Speak" << endl;
    }
    virtual void eat(int i)
    {
        cout << "Cat Eat" << i << endl;
    }
};

void test()
{
    Animal * animal = new Cat;
    //cat->speak();
    //((void(*)())  (*(int*)*(int*)animal))();Cat Speak--32位调试才能跑
    //((void(*)()) (*((int*)*(int*)animal + 1)))();//Cat Eat--无参
    typedef void(__stdcall* FUNC)(int);
    (FUNC(*((int*)*(int*)animal + 1)))(10);//Cat Eat10--有参
}

3.抽象类和纯虚函数

  • 纯虚函数语法：virtual void func() = 0;
  • 如果一个类中有纯虚函数，那么这个类无法实例化对象，这样的类称为抽象类
  • 如果子类继承了抽象类，那么子类必须重写父类中的纯虚函数，否则子类也属于抽象类
//##利用多态实现计算器
class AbstractCalculator//抽象类
{
public:
    virtual int getResult() = 0;//纯虚函数
    // virtual int getResult()//虚函数
    // {
    //     return 0;
    // }
    int m_A;
    int m_B;
};
//加法计算器
class AddCalculator : public AbstractCalculator
{
public:
    int getResult()
    {
        return m_A + m_B;
    }
};
void test()
{
    AbstractCalculator* calculator = new AddCalculator;
    calculator->m_A = 10;
    calculator->m_B = 20;
    cout << calculator->getResult() << endl;
}

4.虚析构和纯虚析构

  • 虚析构解决的问题：当子类有堆区的内容时，释放时不干净，内存泄露
  • 纯虚析构：有声明，也必须有实现，在类外实现
  • 如果一个类中有纯虚析构，那么这个类属于抽象类
class Animal
{
public:
    Animal()
    {
        cout << "Animal()" << endl;
    }
    //virtual ~Animal()
    //{//虚析构
    //  cout << "~Animal()" << endl;
    //}
    virtual ~Animal() = 0;//纯虚析构
    virtual void speak()
    {
        cout << "Animal speak()" << endl;
    }
};
Animal::~Animal()
{
    cout << "~Animal()" << endl;
}
class Cat : public Animal
{
public:
    Cat(const char* name)
    {
        this->m_Name = new char[strlen(name) + 1];
        strcpy(this->m_Name, name);

        cout << "Cat()" << endl;
    }
    ~Cat()
    {
        if (this->m_Name != NULL)
        {
            cout << "~Cat()" << endl;
            delete[] this->m_Name;
            this->m_Name = NULL;
        }
    }
    void speak()
    {
        cout << "Cat Speak()" << endl;
    }
    char* m_Name;
};
void test()
{
    Animal* animal = new Cat("DD");
    animal->speak();
    delete[] animal;
}

5.向上向下类型转换

  1. 父类转子类 向下类型转换 不安全
  2. 子类转父类 向上类型转换 安全
  3. 如果发生多态，那么总是安全的

向上向下类型转换

6.多态案例–电脑组装

多态案例--电脑组装

//抽象层
//抽象的CPU
class Cpu
{
public:
    virtual void calculate() = 0;
};
//抽象的显卡
class VideoCard
{
public:
    virtual void memory() = 0;
};
//电脑类
class computer
{
public:
    computer(Cpu* cpu, VideoCard* vc)
    {
        this->cpu = cpu;
        this->vc = vc;
    }
    void dowork()
    {
        this->cpu->calculate();
        this->vc->memory();
    }
    ~computer()
    {
        if (this->cpu != NULL)
        {
            delete[] cpu;
            this->cpu = NULL;
        }
        if (this->vc != NULL)
        {
            delete[] vc;
            this->vc = NULL;
        }
    }
    Cpu* cpu;
    VideoCard* vc;
};
//实现层
//inter的CPU
class interCpu : public Cpu
{
    void calculate()
    {
        cout << "interCpu Calculate()" << endl;
    }
};
//inter的显卡
class interVideoCard : public VideoCard
{
    void memory()
    {
        cout << "interVideoCard Memory()" << endl;
    }
};
//联想的CPU
class leCpu : public Cpu
{
    void calculate()
    {
        cout << "leCpu Calculate()" << endl;
    }
};
//联想的显卡
class leVideoCard : public VideoCard
{
    void memory()
    {
        cout << "leVideoCard Memory()" << endl;
    }
* };~~~~
void test()
{
    //组装的第一台电脑
    Cpu* cpu = new interCpu;
    VideoCard* vc = new interVideoCard;
    computer* interCo = new computer(cpu, vc);
    interCo->dowork();
    //组装的第二台电脑
    cout << "------------" << endl;
    Cpu* cpu2 = new leCpu;
    VideoCard* vc2 = new leVideoCard;
    computer* interCo2 = new computer(cpu2, vc2);
    interCo2->dowork();
}
@阿飞
关注
  • 22
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++基础语法梳理：引用、封装、继承和多态
致力于C语言C++知识分享！
09-10 192
本期是C++基础语法分享的第六节，今天给大家来分享一下： （1）引用； （2）宏； （3）成员初始化列表； （4）封装； （5）继承； （6）多态； 引用 左值引用 常规引用，一般表示对象的身份。 右值引用 右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。 右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面： 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提
C++继承与多态（一）
HelloKTT的博客
07-21 937
一、继承相关概念     1.继承：继承是面向对象复用的重要手段。通过继承定义一个类，继承是类型之间的关系建模，共享共有的东西，实现各自本质不同的东西。     2.成员访问限定符与继承的关系               继承是一种复用手段，在继承关系里基类继承派生类的成员，由此打到复用目的。        三种继承关系下基类成员在派生类的访问关系变化
C++语法（15）---- 继承
竹杖芒鞋轻声马
04-12 631
介绍了三大面向对象特点之一的继承
C++基础语法（五）继承——万字总结，干货满满
cdzg_zzk的博客
10-11 1822
C++继承继承是什么、为什么会出现继承1、什么样的场景会使用继承2、什么是继承3、继承的语法继承方式1、访问限定修饰符的作用（1）修饰类中成员（2）修饰继承方式基类\派生类对象赋值兼容问题（切割问题）1、基类\派生类对象赋值兼容的基本概念2、其他类型的切割指针赋值引用赋值继承中的作用域隐藏\遮蔽遮蔽的概念及理解遮蔽与函数重载派生类的默认成员函数1、构造函数2、拷贝构造3、operator=( )4、析构函数多继承单继承与多继承的概念菱形继承菱形继承的坑虚继承终极问题：C++如何通过虚继承解决数据冗余以及二义
C++编程——继承
professor_tao的博客
04-25 3784
文章目录1. 继承的基本语法2. 继承方式 继承的知识点结构： 继承是面向对象三大特性之一，例如动物类下可以有猫类、狗类。显然猫类、狗类都具有动物类的属性，于此同时，也就有自己独特的属性。这个时候，猫类、狗类就是继承于动物类，采用继承的技术，可以减少重复的代码。 1. 继承的基本语法 语法：class 子类：继承方式 基类 继承示例： 一般网页都有很多部分相似的，我们可以将这些相似的部分抽象出来，作为一个基类。然后子类只需要继承基类，在基类的基础上添加自身其他的属性或者方法就可以实现基本的功能，同时减少
C++的protected
图像学习之旅
02-01 3325
基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。 也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。 2) 不管继承方式如何，基类中的 privat
C++继承，语法+案例，超详细！！
m0_62951223的博客
08-31 2843
C++继承
C++语法基础各章习题.zip
04-10
这个"C++语法基础各章习题.zip"压缩包包含了一系列针对C++初学者的练习题，适用于指导少儿编程教学和CSP（中国青少年信息学奥林匹克竞赛）的备考训练。这些习题覆盖了C++基础语法的各个方面，旨在帮助学生逐步掌握并...
Python自学教程-03-体验多态思路分析.ev4.rar
12-26
虽然Python并不直接支持像Java或C++那样的方法重载，但其动态类型特性使得多态的实现更加灵活。在Python中，多态主要通过继承和接口实现。 1. 继承（Inheritance）：一个类可以继承另一个类的属性和方法，这样就...
MOEA/D的C++代码
02-05
MOEA/D的C++源代码，很好的资源哟，做多目标算法不可缺少的哟！
C++经典实例——体现继承和多态
07-30
在C++编程语言中，继承和多态是面向对象编程（OOP）的两大核心概念。这个名为“C++经典实例——体现继承和多态”的资源显然是为了帮助开发者深入理解和应用这两个关键特性。下面我们将详细探讨这两个主题以及它们在...
Java语法基础-面试专题及答案
01-28
11.Java 面向对象编程三大特性: 封装 继承 多态 关于继承的3点 12.String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的 可变性、线程安全性的研究 13.自动装箱与拆箱 14.在一个静态方法内...
C++基础语法——继承
qq_73201597的博客
08-17 654
在这里我们先举一个例子public:protected:// 姓名// 年龄protected:int _stuid;// 学号protected:int _jobid;// 工号同一个人它有可能同时具有多重身份，在上述例子中他可能就同时具有老师和学生两个身份，这两个身份有一些相同点（如它们都是人，所具有的年龄和姓名不会变化），也有一些不同点（如作为老师时有工号，学生时有学号）。了解这个例子之后我们大概就了解到了继承是什么，那么我们如何来书写它呢？
【C++】继承(详解)
m0_64826370的博客
06-27 1309
C++中的继承是一种面向对象编程的特性，它允许一个类（子类）继承另一个类（父类）的属性和方法，并且可以添加自己的属性和方法。通过继承，子类可以重用父类的代码，减少重复编写代码的工作量。在C++中，使用关键字"extends"可以声明一个类继承另一个类。子类将自动继承父类的非私有成员和方法，并可以通过重写（override）父类的方法或添加新方法来实现自己的行为。(光看文字大家肯定还是觉得晦涩难懂的，我们直接看代码)
【C++】继承详解
m0_69442905的博客
09-14 634
本篇介绍了，C++继承的基本概念，基类和派生类对象的赋值转换，继承作用域，派生类的默认成员函数，继承和友元的关系，静态成员变量的继承，菱形继承和虚拟继承的原理，继承和组合等概念，以及使用简单调试进行理解继承
C++之继承
m0_74893211的博客
05-25 289
继承是面向对象的三大特性之一。利用好继承可以很好的减少重复代码，使程序更加简洁。
C++基础语法（继承）
m0_61350245的博客
10-02 199
继承(inheritance)是类的三大特性之一，继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用继承的概念并不难理解，接下来我们举个例子来看看，继承是如何实现代码的复用的。
C语言 之 理解指针（1）
最新发布
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++基础：封装、继承与多态详解
C++作为一门强大的编程语言，以其独特的面向对象特性而闻名，其核心概念包括封装、继承和多态。封装是信息隐藏的基础，通过将数据和操作捆绑在一起，保护对象内部的细节，只对外提供预定义的方法接口。C++中，成员的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值