斗破C++编程入门系列之三十：继承与派生：派生类对基类成员的访问控制之公有继承（一星斗师）-CSDN博客

本文链接：https://blog.csdn.net/windxf/article/details/142310288

斗破C++目录：

鸡啄米C++

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

斗破观看顺序：

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

一、女王的祭祀

萧炎和药老通过地洞来到一处神秘之地，原来在神殿的底下居然隐藏着一片神奇之处。
另一边，丹王古河与云芝寻着异火的气息来到了神殿的一角，虽然找到了异火，但是却先前美杜莎女王让人放置的假异火。
在神殿外，闻声赶来的蛇族将军墨巴斯，加入了保卫蛇族的队伍，严狮和风黎很快就落入下风。还好丹王与云芝的及时赶到才救下此二人。
而此时，当萧炎与药老经过一片碧绿的湖水，湖水中有剧毒，所以萧炎只能依靠药老的保护才能游过此处，谁知湖中早已潜藏的毒蛇正慢慢跟在萧炎身后，无心恋战的萧炎使用爆步冲出湖水，并在祭坛中央再次见到了美杜莎女王。
美杜莎女王虽然发现了萧炎，但是她知道自己这次祭祀九死一生，就没有再过多理会萧炎。在吞噬异火的过程美杜莎女王十分虚弱，并危在旦夕，萧炎能否此时拿回异火？是福是祸？再来分解。

二、C++：继承与派生：派生类对基类成员的访问控制之公有继承（一星斗师）

公有继承public我们之前示范过，这里详细说明其继承的部分。

子类会继承父类的public和protected属性的变量及函数，子类公有继承的成员属性与父类相同，即父类public的属性在子类内部也是public，父类的protected属性在子类内部也是protected。
但是有一点，父类的private属性成员不可继承。

我们示范一下代码：
我们为远古灵生新增一个protected和private的成员函数：

#ifndef ANCIENTSNAKE_H
#define ANCIENTSNAKE_H

#include <QDebug>


class AncientSnake
{
public:
    AncientSnake();

public:

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

protected:
    void swallow_strange_fire(){
        qDebug() << "吞噬异火";
    }

private:
    void use_ancient_unique_skill(){
        qDebug() << "远古灵蛇独有的秘技";
    }

};

#endif // ANCIENTSNAKE_H

我们知道子类可以继承父类public属性的函数，那protected能否继承呢？看看这段代码能否编译通过就知道了。

#ifndef QUEEN_H
#define QUEEN_H

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

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

public:
    //定义与父类相同的成员函数
    void use_ancient_fighting_skill(){
        qDebug() << "使用蛇族远古斗技 升级版本";
    }

public:
    //定义与父类相同的成员变量
    QString name;

public:
    //定义自己的函数
    void use_secret_skill(){
       qDebug() << "使用蛇族秘术";
       
       //调用远古灵蛇的protected属性函数
       swallow_strange_fire();
    }

};

#endif // QUEEN_H

尝试发现，可以编译通过，这说明子类可以调用父类的swallow_strange_fire函数（protected属性）。
最后我们再尝试调用父类的私有成员函数，看看编译器会报什么错误？

#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);

    //调用与父类相同的成员函数
    meidusha.use_ancient_fighting_skill();
    //调用与父类相同的成员变量
    qDebug() << " meidusha.name " << meidusha.name;
    //调用自己的函数,内部调用了远古灵蛇的protected函数
    meidusha.use_secret_skill();
    
    //看看编译会不会报错，美杜莎能否使用远古灵蛇的private属性函数
    meidusha.use_ancient_unique_skill()

    return a.exec();
}

大家编译一下便知结果，这也印证了我们之前说的，protected属性只有在使用继承时才有作用，当子类公有继承父类时，对子类可见。protected即保护的意思，他只将自己的秘密对继承家业的子孙开放，外人是不知道的。

protected属性其实很少用到，这里我们不用作为重点，一般我们只是使用public继承和使用public属性的成员。

三、英语

先来看几个单词：

public 公有
protect 保护
ancient 远古的
unique 独一无二的

再来看几个句子：

During（在…） the process（过程） of（的） devouring（吞噬） the strange fire（异火）, Queen（女王） Medusa（美杜莎） was very（十分） weak（虚弱） and（而且） in imminent danger（危在旦夕）.
在吞噬异火的过程中美杜莎女王十分虚弱，并危在旦夕。

During 引导一个时间状语从句，表示在…的一段时间内。
in imminent danger 短语表示 “危在旦夕”。