斗破C++编程入门系列之二十八：继承与派生：概念介绍与派生类的声明（一星斗师）

🕗 发布于 2024-09-17 02:05 c++ java

斗破C++目录：

鸡啄米C++

记住首页不迷路：
http://www.jizhuomi.com/software/129.html

斗破观看顺序：

https://v.haohuitao.cc/yhplay/336-1-2.html
第一季☞第二季前2集☞特别篇1☞第二季3～12集☞特别篇2沙之澜歌☞第三季☞第四季☞三年之约☞缘起☞年番
斗气大陆等级：
斗气有十一个阶别，斗之气，斗者，斗师，大斗师，斗灵，斗王，斗皇，斗宗，斗尊，斗圣，斗帝。
斗气大陆上很久没有出现过斗帝了。

一、女王的祭祀

原来通过祭祀的方式，美杜莎女王才能够晋升斗宗，但是同时还需要异火的帮助，而此过程也不是一帆风顺，稍有不慎就会如同飞蛾扑火。
而丹王古河此行的目的也是为了异火，他令手下严狮和风黎与月媚交手，以防止月媚把他们的行踪泄露出去，月媚虽然不是他们的对手，但是通过族中秘法，侥幸逃脱，并速将此消息传达给了美杜莎女王。
另一边，萧炎和药老根据地图也找到了蛇族神殿，无奈守卫森严，即使使用了蛇形丹化为蛇形，也没能逃过士兵的眼睛。祭祀已经开始，萧炎无可奈何的跟随蛇众学起了祭祀动作。此时天空中一只厚翼鸟的到来，打破了这里祥和宁静的祭祀过程。
女王能否祭祀成功？丹王能否如愿拿到异火？这场纷争就像沙漠中的烈日，烧的人心惶惶，后续如何再见分解。

二、C++：继承与派生：概念介绍与派生类的声明（一星斗师）

继承是C++中最为核心的概念，它最主要的目的是为了实现代码的复用，它独特的提出了父类与子类的概念。我们抛出个问题：比如A实现了一大堆功能，然后B想使用A的功能怎么办？
在没有使用继承之前，我们学习过类的组合，那我们可以让A成为B的成员变量，这样我们就可以使用A的函数功能了。
使用组合可以实现我们的功能，但是也有缺点，那就是我们新增的任何类，都要重新定义新的接口，因为类与类之间是没有关联的、无法相互转换。而父类与子类概念的提出，使得这一问题得到解决。父类就像是我们定义好的公共接口，而新增的类作为父类的子类，可以在不改变原有接口的方式下，实现新增的功能，实现原有代码的复用及拓展。这就是派生的意义，它实现了代码的拓展和新生。因为类与类之间是有关联的。
继承有三种方式，public继承、protected继承、private继承。
一般我们只用public继承，protected继承很少使用，几乎不用private继承。
下面看看代码：
创建远古灵蛇类

#ifndef ANCIENTSNAKE_H
#define ANCIENTSNAKE_H

#include <QDebug>


class AncientSnake
{
public:
    AncientSnake();

public:

    void use_ancient_fighting_skill(){
        qDebug() << "使用蛇族远古斗技";
    }

};

#endif // ANCIENTSNAKE_H

创建女王类，女王类同时继承远古灵蛇类和人类

#ifndef QUEEN_H
#define QUEEN_H

#include "ancientsnake.h"
#include "person.h"

//美杜莎女王继承了远古斗技
//美杜莎女王继承了人类的形态
class Queen
 : public AncientSnake
 , public Person<double>
{
public:
    Queen();
};

#endif // QUEEN_H

然后使用女王类

#include "mainwindow.h"

#include <QApplication>
#include <QDataStream>
#include <QDebug>

#include <person.h>
#include <Function.h>
#include <iostream>
#include <queen.h>

//类模版的静态成员初始化
//静态成员初始化只能在函数体外
template <typename T>
int Person<T>::count=0;

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    //指定模版类型
    Person<double> xiaoyan("xiaoyan",17,8); //萧炎

    {
        //加了大括号之后，都是xiaoyan，但是不冲突，
        //括号内的xiaoyan与括号外的无关系
        Person<double> xiaoyan("xiaoyan2",18,9); //萧炎
    }

    test_survival_period();

    Person<double> xuner("xuner", 16, 15);

    qDebug() << "萧炎目前的斗之气等级 " << xiaoyan.level;
    level_up(xiaoyan);
    qDebug() << "升级后的斗之气等级 " << xiaoyan.level;

    //使用重载函数，连升3级别
    level_up(xiaoyan,3);
    qDebug() << "升级后的斗之气等级 " << xiaoyan.level;

    Monster snake; //岩蛇
    snake.name = "snake";
    snake.level = 1;

    qDebug() << "岩蛇目前的斗之气等级 " << snake.level;
    level_up(snake);
    qDebug() << "岩蛇升级后的斗之气等级 " << snake.level;
    //指定模版类型
    bool outcome = xiaoyan.fight(snake);

    qDebug() << "萧炎与岩蛇的战斗结果 " << outcome;

    qDebug() << "萧炎目前的斗技 " << xiaoyan.skill.name;
    //斗技
    Skill skill;
    skill.name = "八级崩";

    //赋值给萧炎新的斗技
    xiaoyan.skill = skill;

    qDebug() << "萧炎目前的斗技 " << xiaoyan.skill.name;


    //这里把level_up的参数改成了常引用，
    //试试编译有报错吗？

    //这里定义一个常对象
    const bool victory = true;
    //修改victory看看编译有报错吗？
    //victory = false;

    //使用数组
    //Person<double>* person_set[3];
    //Skill skill_set[3];

    Skill skill_1("吸掌");
    Skill skill_2("八级崩");
    Skill skill_3("爆步");

    /*
    skill_set[0] = skill_1;
    skill_set[1] = skill_2;
    skill_set[2] = skill_3;

    for(int i=0; i<3; i++){
        qDebug() << "i " << i
                 << skill_set[i].name;
    }
    */

    //数组初始化
    Skill skill_set[3] = {skill_1 , skill_2, skill_3};

    for(int i=0; i<3; i++){
        qDebug() << "i " << i
                 << skill_set[i].name;
    }

    //数组作为参数
    print_all_skill(skill_set, 3);

    //非指针类型对象
    Person<double> Frank("Frank",35,9);
    //指针类型对象
    Person<double>* Yao_lao = new Person<double>("yaolao",45,88);

    qDebug() << " Frank is Pointer ? " << isPointer(Frank);
    //使用&将普通对象转为指针类型。
    Person<double>* Frank_copy = &Frank;
    qDebug() << " Frank_copy is Pointer ? " << isPointer(Frank_copy);

    qDebug() << " Yao_lao is Pointer ? " << isPointer(Yao_lao);
    //使用*转换为普通对象
    qDebug() << " Yao_lao is Pointer ? " << isPointer(*Yao_lao);


    //使用自增和自减操作指针
    Skill* p = skill_set;
    qDebug() << "p "  << p->name;
    p++;
    qDebug() << "p "  << p->name;
    p++;
    qDebug() << "p "  << p->name;

    //定义一个指针数组
    Person<double>* person_set[3];
    person_set[0] = new Person<double>("小医仙",18,6);
    person_set[1] = new Person<double>("萧鼎",19,16);
    person_set[2] = new Person<double>("萧厉",18,15);

    qDebug() << person_set[0]->name << " level " << person_set[0]->level;
    qDebug() << person_set[1]->name << " level " << person_set[1]->level;
    qDebug() << person_set[2]->name << " level " << person_set[2]->level;

    //函数名为指针,
    //定义指针的类型为：bool can_find_fire(Person<double> * person)
    // 使用std::function声明一个函数指针
    std::function<bool(Person<double>*)> func = can_find_fire;

    //调用func
    func(person_set[0]);

    //释放指针占用的内存
    delete person_set[0];
    delete person_set[1];
    delete person_set[2];

    //
    std::string message_1 = "xiaoyan ";
    std::string message_2 = "meet ";
    std::string message_3 = "meidusha";

    //拼接字符串
    std::string message = message_1 + message_2 + message_3;
    qDebug() << "message " << QString::fromStdString(message);

    //裁剪字符串
    std::string substr = message.substr(13,8);
    qDebug() << "message substr " << QString::fromStdString(substr);

    //交换字符串
    message_1.swap(message_3);
    qDebug() << "message_1 " << QString::fromStdString(message_1);
    qDebug() << "message_3 " << QString::fromStdString(message_3);


    //创建女王对象
    Queen meidusha;
    //女王调用远古灵蛇的斗技
    meidusha.use_ancient_fighting_skill();
    //创建怪物类
    Monster monkey;
    monkey.name = "岩猿";
    monkey.level = 1;
    //女王调用人类的函数打怪兽
    meidusha.fight(monkey);

    return a.exec();
}

由于女王类同时继承了远古灵蛇类和人类，所以同时拥有远古灵蛇和人所开放的接口函数，这就是继承的作用。因为美杜莎女王同时拥有蛇与人的2种形态，所以代码中可以使用继承的方式实现。

注意：继承的类，在构造时要为其父类指定构造函数，所以我们使用如下的构造函数为女王类进行构造：

#include "queen.h"

Queen::Queen()
    :AncientSnake() //初始化远古灵蛇
    ,Person<double>("name", 16, 16) //初始化人类
{

}

三、英语

先来看几个单词：

inherit 继承
derive 派生
statement 声明
queen 女王

再来看几个句子：

This（这个） dispute（纷争） is（就） like（像） the（这） scorching（灼热的） sun（太阳） in（在） the（这） desert（沙漠）, burning（烧） people（人） with（带着） fear（恐惧） and（和） anxiety（焦虑）.
这场纷争就像沙漠中的烈日，烧的人心惶惶。

burning people with fear and anxiety 为动词现在分词引导的定语从句，来修饰sun。可以认为省略了which，完整的句子可以改为 which burn people with fear and anxiety。

原文地址：https://blog.csdn.net/windxf/article/details/142302735

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Java【异常处理】
下一篇：人如酒，岁月沉淀方显卓越！

Redis——分布式锁
为什么要有分布式锁？在只有一台服务器提供服务的情况下，乐观锁和悲观锁足以解决线程并发导致的问题。但是企业开发中避免不了需要部署多台服务器，即采用分布式系统或集群模式，这时，多台服务器就有多个jvm，对
阅读更多2024-09-20
springboot使用minio(8.5.11)
1.配置minio MinioAutoConfiguration 类。3.创建minioTemplate工具类。1.上传时如果流是空的，不上传不成功的。
阅读更多2024-09-20
Redis的Key的过期策略是怎样实现的？
在学习Redis时，我们知道可以设置Key的过期时间，我们还知道，Redis一大特点–。那么当Redis中的数据量起来时，如果直接遍历所有的Key，那么对于Key过期时间的校验应该很费时间，那么Red
阅读更多2024-09-20
电气自动化入门03：安全用电
人体电阻：人体平均电阻：2000欧姆，计算分析时，通常去下线值1700欧姆；2.1 电工知识：触电原因与防触电措施_哔哩哔哩_bilibili。电磁场生理伤害：高频磁场影响人的神经系统；违章冒险
阅读更多2024-09-20
828 华为云征文｜华为 Flexus 云服务器搭建 PicGo 图床
通过在华为 Flexus 云服务器上搭建 PicGo 图床，我们成功地构建了一个高效、稳定的图片存储和管理平台。无论是个人博客、开发者文档还是其他需要图片资源的场景，都能从中受益。在未来，随着需求的不
阅读更多2024-09-20
Pycharm打印区打印数据不全问题
python
阅读更多2024-09-20
git重置本地提交与远程保持一致
【代码】git重置本地提交与远程保持一致。
阅读更多2024-09-20
阿里巴巴拍立淘API返回值：商家优化商品信息的深度指南
阿里巴巴的拍立淘API为商家提供了一个强大的工具，通过其返回值，商家可以深入了解市场竞品，并据此制定有效的商品信息优化策略。通过不断优化商品图片、标题、价格等关键信息，商家可以提升商品的竞争力和市场接
阅读更多2024-09-20
Java入门：09.Java中三大特性（封装、继承、多态）02
比如：类A 继承类BA类称为子类，衍生类，派生类B类称为父类，基类，超类子类自动的拥有父类的所有属性和方法（父类编写，子类不需要再编写）。代码复用目前私有的属性和方法无法访问。多态的基
阅读更多2024-09-20
力扣560 和为k的子数组 Java版本
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。输入：nums = [1,1,1], k = 2。输入：nums = [1,2,3], k = 3。子数
阅读更多2024-09-20