C++类和对象-继承-＞基本语法、继承方式、继承中的对象模型、继承中构造和析构顺序、继承同名成员处理方式、继承同名静态成员处理方式、多继承语法、菱形继承

#include<iostream>
using namespace std;

//普通实现页面
//Java页面
//class Java
//{
//public:
//    void header()
//    {
//        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
//    }
//    void footer()
//    {
//        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
//    }
//    void left()
//    {
//        cout << "Java,Python,C++...(公共分类列表)" << endl;
//    }
//    void content()
//    {
//        cout << "JAVA学科视频" << endl;
//    }
//};
Python页面
//class Python
//{
//public:
//    void header()
//    {
//        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
//    }
//    void footer()
//    {
//        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
//    }
//    void left()
//    {
//        cout << "Java,Python,C++...(公共分类列表)" << endl;
//    }
//    void content()
//    {
//        cout << "Python学科视频" << endl;
//    }
//};
C++页面
//class CPP
//{
//public:
//    void header()
//    {
//        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
//    }
//    void footer()
//    {
//        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
//    }
//    void left()
//    {
//        cout << "Java,Python,C++...(公共分类列表)" << endl;
//    }
//    void content()
//    {
//        cout << "C++学科视频" << endl;
//    }
//};
//
//void test01()
//{
//    //Java页面
//    cout << "Java下载视频页面如下： " << endl;
//    Java ja;
//    ja.header();
//    ja.footer();
//    ja.left();
//    ja.content();
//    cout << "--------------------" << endl;
//
//    //Python页面
//    cout << "Python下载视频页面如下： " << endl;
//    Python py;
//    py.header();
//    py.footer();
//    py.left();
//    py.content();
//    cout << "--------------------" << endl;
//
//    //C++页面
//    cout << "C++下载视频页面如下： " << endl;
//    CPP cp;
//    cp.header();
//    cp.footer();
//    cp.left();
//    cp.content();
//
//}
//
//int main()
//{
//    test01();
//
//    system("pause");
//    return 0;
//}

//继承实现页面
//公共页面
class BasePage
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }

    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java,Python,C++...(公共分类列表)" << endl;
    }

};
//继承的好处：减少重复代码
//语法：  class 子类:继承方式 父类
//子类  也称为  派生类
//父类  也称为   基类

//Java页面
class Java : public BasePage
{
public:
    void content()
    {
        cout << "JAVA学科视频" << endl;
    }
};
//Python页面
class Python : public BasePage
{
public:
    void content()
    {
        cout << "Python学科视频" << endl;
    }
};
//C++页面
class CPP : public BasePage
{
public:
    void content()
    {
        cout << "C++学科视频" << endl;
    }
};

void test01()
{
    //Java页面
    cout << "Java下载视频页面如下： " << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
    cout << "--------------------" << endl;

    //Python页面
    cout << "Python下载视频页面如下： " << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    cout << "--------------------" << endl;

    //C++页面
    cout << "C++下载视频页面如下： " << endl;
    CPP cp;
    cp.header();
    cp.footer();
    cp.left();
    cp.content();


}

int main() {

    test01();

    system("pause");

    return 0;
}

#include<iostream>
using namespace std;

//继承方式
//公共继承
class Base1
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son1 :public Base1
{
public:
    void func()
    {
        //可访问 public权限
        m_A;//父类中的公共权限成员 到子类中依然是公共权限
        //可访问 protected权限
        m_B; //父类中的保护权限成员 到子类中依然是保护权限
        //不可访问
        //m_C; //父类中的私有权限成员  子类访问不到
    }
};

void myClass()
{
    Son1 s1;
    s1.m_A = 100; //其他类只能访问到公共权限
    //s1.m_B = 100;//到Son1中 m_B是保护权限 类外访问不到
}

//保护继承
class Base2
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
class Son2:protected Base2
{
public:
    void func()
    {
        //可访问 protected权限
        m_A;   //父类中公共成员，到子类中变为保护权限
        //可访问 protected权限
        m_B;   //父类中保护成员，到子类中变为保护权限
        //不可访问
        //m_C; //父类中私有成员  子类访问不到
    }
};
void myClass2()
{
    Son2 s;
    //不可访问
    //s.m_A = 100; //在Son2中 m_A变为保护权限，因此类外访问不到
    //s.m_B = 100; //在Son2中 m_B变保护权限，不可以访问
}

//私有继承
class Base3
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
class Son3:private Base3
{
public:
    void func()
    {
        //可访问 private权限
        m_A; //父类中公共成员，到子类中变为私有成员
        //可访问 private权限
        m_B; //父类中保护成员，到子类中变为私有成员
        //不可访问
        //m_C; //父类中私有成员  子类访问不到
    }
};

class GrandSon3 :public Son3
{
public:
    void func()
    {
        //Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
        //m_A = 1000;//到了Son3中 m_A变为私有，即使是儿子，也是访问不到
        //m_B = 1000;//到了Son3中 m_B变为私有，即使是儿子，也是访问不到

    }
};

void myClass3()
{
    Son3 s;
    //不可访问
    //s.m_A = 1000; //在Son3中 变为私有成员  类外访问不到
    //s.m_B = 1000; //在Son3中 变为私有成员  类外访问不到
}

#include<iostream>
using namespace std;

//继承中的对象模型
class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};

//公共继承
class Son :public Base
{
public:
    int m_D;
};

//利用开发人员命令提示工具查看对象模型
//跳转盘符 F：
//跳转文件路径 cd 具体路径下
//查看命名
//cl /d1 reportSingleClassLayout类名 文件名

void test01()
{
    //16
    //父类中所有非静态成员属性都会被子类继承下去
    //父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
    cout << "sizeof Son = " << sizeof(Son) << endl;
}

int main() {

    test01();

    system("pause");

    return 0;
}

结论：父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

#include<iostream>
using namespace std;

//继承中的构造和析构顺序
class Base
{
public:
    Base()
    {
        cout << "Base构造函数!" << endl;
    }
    ~Base()
    {
        cout << "Base析构函数!" << endl;
    }
};

class Son : public Base
{
public:
    Son()
    {
        cout << "Son构造函数!" << endl;
    }
    ~Son()
    {
        cout << "Son析构函数!" << endl;
    }

};


void test01()
{
    //继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
    Son s;
}

int main() {

    test01();

    system("pause");

    return 0;
}

总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

#include<iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }

    void func()
    {
        cout << "Base - func()调用" << endl;
    }

    void func(int a)
    {
        cout << "Base - func(int a)调用" << endl;
    }

public:
    int m_A;
};


class Son : public Base
{
public:
    Son()
    {
        m_A = 200;
    }

    //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
    //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
    void func()
    {
        cout << "Son - func()调用" << endl;
    }
public:
    int m_A;
};

void test01()
{
    Son s;

    //同名成员属性
    cout << "Son下的m_A = " << s.m_A << endl;
    //如果通过子类对象 访问到父类中同名成员，需要加作用域
    cout << "Base下的m_A = " << s.Base::m_A << endl;

    //同名成员函数
    s.func();//直接调用 调用的是子类中的同名成员
    s.Base::func();
    s.Base::func(10);

}
int main() {

    test01();

    system("pause");
    return EXIT_SUCCESS;
}

总结：

1. 子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以访问到父类同名成员
3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

#include<iostream>
using namespace std;

//继承中的同名静态成员处理方式
class Base
{
public:
    static void func()
    {
        cout << "Base - static void func()" << endl;
    }
    static void func(int a)
    {
        cout << "Base - static void func(int a)" << endl;
    }

    static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
    static void func()
    {
        cout << "Son - static void func()" << endl;
    }
    static int m_A;
};

int Son::m_A = 200;

//同名静态成员属性
void test01()
{
    //1.通过对象访问
    cout << "通过对象访问： " << endl;
    Son s;
    cout << "Son  下 m_A = " << s.m_A << endl;
    cout << "Base 下 m_A = " << s.Base::m_A << endl;

    //2.通过类名访问
    cout << "通过类名访问： " << endl;
    cout << "Son  下 m_A = " << Son::m_A << endl;
    //第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
    cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名静态成员函数
void test02()
{
    //1.通过对象访问
    cout << "通过对象访问： " << endl;
    Son s;
    s.func();
    s.Base::func();
    //2.通过类名访问
    cout << "通过类名访问： " << endl;
    Son::func();
    Son::Base::func();
    //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
    Son::Base::func(100);
}
int main() {

    //test01();
    test02();

    system("pause");

    return 0;
}

 总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

#include<iostream>
using namespace std;

//多继承语法

class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
public:
    int m_A;
};

class Base2 {
public:
    Base2()
    {
        m_A = 200;  //开始是m_B 不会出问题，但是改为m_A就会出现不明确
    }
public:
    int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2
class Son : public Base2, public Base1
{
public:
    Son()
    {
        m_C = 300;
        m_D = 400;
    }
public:
    int m_C;
    int m_D;
};


//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
    Son s;
    cout << "sizeof Son = " << sizeof(s) << endl;
    //当父类中出现同名成员，需要加作用域区分
    cout << s.Base1::m_A << endl;
    cout << s.Base2::m_A << endl;
}

int main()
{

    test01();

    system("pause");

    return 0;
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

#include<iostream>
using namespace std;

//动物类
class Animal
{
public:
    int m_Age;
};
//利用虚继承 解决菱形继承的问题
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
//羊类
class Sheep : virtual public Animal {};
//驼类
class Tuo   : virtual public Animal {};
//羊驼类
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 100;
    st.Tuo::m_Age = 300;
    //当菱形继承，两个父类拥有相同数据，需要加以作用域区分
    cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
    cout << "st.m_Age = " << st.m_Age << endl;
    //这份数据我们知道  只有一份就可以，菱形继承导致数据有两份，资源浪费
    
}


int main() {

    test01();

    system("pause");

    return 0;
}

总结：

* 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
* 利用虚继承可以解决菱形继承问题

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/683264.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

python 算法之 克鲁斯卡尔算法

python 算法之 克鲁斯卡尔算法

文章目录 原理代码实现 原理 克鲁斯卡尔&#xff08;Kruskal&#xff09;算法是一种用于求解最小生成树&#xff08;Minimum Spanning Tree&#xff0c;MST&#xff09;的贪心算法。最小生成树是一个连通加权无向图中生成树&#xff08;即包含图中所有顶点并且是一棵树&#xf…
阅读更多...
C++预处理命令与宏定义

C++预处理命令与宏定义

C的预处理命令用于在编译源代码之前进行一些处理。预处理器指令以井号&#xff08;#&#xff09;开头&#xff0c;常用于包含头文件、宏定义和条件编译等操作。以下是几个常见的C预处理命令&#xff1a; 包含文件 #include <iostream> // 包含标准库头文件 #include &…
阅读更多...
Vuex使用

Vuex使用

Vuex 一、概述 二、State 存放状态的 1、创建state const state {title: 我是一个标题,content: 今天的天气是好的,age: 2, };2、使用 直接在页面直接使用 //非模块化写法 <div>{{ $store.state.title }}</div> //模块化写法 <div>{{ $store.state.abo…
阅读更多...
前端秘法基础式(HTML)(第二卷)

前端秘法基础式(HTML)(第二卷)

目录 一.表单标签 1.表单域 2.表单控件 2.1input标签 2.2label/select/textarea标签 2.3无语义标签 三.特殊字符 一.表单标签 用来完成与用户的交互,例如登录系统 1.表单域 <form>通过action属性,将用户填写的数据转交给服务器 2.表单控件 2.1input标签 type…
阅读更多...
【30秒看懂大数据】数据中台

【30秒看懂大数据】数据中台

知幽科技是一家专注企业数字/智化&#xff0c;围绕数据价值应用的一站式数智化解决方案的咨询公司&#xff0c;也包括了为企业提供定制化数据培训&#xff0c;力求做企业最好的数智化决策伙伴。 点击上方「蓝字」关注我们 30秒看懂大数据专栏 让您在有限的碎片化时间&#xf…
阅读更多...
六、Mybatis注解开发

六、Mybatis注解开发

1.MyBatis的常用注解 注解开发越来越流行&#xff0c; Mybatis也可以使用注解开发方式&#xff0c;这样就可以减少编写Mapper映射文件。Insert&#xff1a;实现新增Update&#xff1a;实现更新Delete&#xff1a;实现删除Select&#xff1a;实现查询Result&#xff1a;实现结果…
阅读更多...
(09)Hive——CTE 公共表达式

(09)Hive——CTE 公共表达式

目录 1.语法 2. 使用场景 select语句 chaining CTEs 链式 union语句 insert into 语句 create table as 语句 前言 Common Table Expressions&#xff08;CTE&#xff09;&#xff1a;公共表达式是一个临时的结果集&#xff0c;该结果集是从with子句中指定的查询派生而来…
阅读更多...
DS：二叉树的顺序结构及堆的实现

DS：二叉树的顺序结构及堆的实现

创作不易&#xff0c;兄弟们给个三连&#xff01;&#xff01; 一、二叉树的顺序存储 顺序结构指的是利用数组来存储&#xff0c;一般只适用于表示完全二叉树&#xff0c;原因如上图&#xff0c;存储不完全二叉树会造成空间上的浪费&#xff0c;有的人又会问&#xff0c;为什么…
阅读更多...
Docker之Oracle-XE版本安装

Docker之Oracle-XE版本安装

Docker之Oracle-XE版本安装 文章目录 Docker之Oracle-XE版本安装1. docker中安装Oracle11gR2-XE1. 拉取镜像2. Quick Start(快速开始)3. 快速安装案例1. 运行docker容器2. 创建用户与授权3. 导出备份数据 1. docker中安装Oracle11gR2-XE dockerhub参考地址: https://hub.docker…
阅读更多...
linux 09 软件安装,YUM

linux 09 软件安装,YUM

下载软件时候&#xff0c;windows会从网上下载exe文件。 windows中的exe文件linux中的rpm文件 简介部分&#xff1a; 其中的认识RPM包&#xff1a; YUM&#xff08;软件包管理工具&#xff09; 01.YUM工具简介 02.使用YUM 第一 安装YUM 全新安装&#xff1a; 01.先pin…
阅读更多...
linux系统zabbix监控配置钉钉告警

linux系统zabbix监控配置钉钉告警

zabbix配置钉钉告警 配置钉钉告警环境准备配置钉钉脚本文件钉钉日志目录编写脚本浏览器配置钉钉告警中文消息告警模版为用户添加报警媒介添加监控项》添加触发器》 添加玩监控项和触发器后添加动作 配置钉钉告警 环境准备 创建钉钉内部群创建自定义机器人记录加签地址和webho…
阅读更多...
Web安全研究（六）

Web安全研究（六）

文章目录 HideNoSeek: Camouflaging(隐藏) Malicious JavaScript in Benign ASTs文章结构Introjs obfuscationmethodologyExample HideNoSeek: Camouflaging(隐藏) Malicious JavaScript in Benign ASTs CCS 2019 CISPA 恶意软件领域&#xff0c;基于学习的系统已经非常流行&am…
阅读更多...
DS：二叉树的链式结构及实现

DS：二叉树的链式结构及实现

创作不易&#xff0c;友友们给个三连吧&#xff01;&#xff01; 一、前言 前期我们解释过二叉树的顺序结构&#xff08;堆&#xff09;为什么比较适用于完全二叉树&#xff0c;因为如果用数组来实现非完全二叉树&#xff0c;那么数组的中间部分就可能会存在大量的空间浪费。 …
阅读更多...
Linux操作系统基础（十四）：集群服务器搭建

Linux操作系统基础（十四）：集群服务器搭建

文章目录 集群服务器搭建 一、新增Linux服务器 1、克隆虚拟机 2、修改虚拟机的硬件配置 3、修改虚拟机的网络配置 二、关闭防火墙 1、关闭firewalld 2、关闭SElinux 三、修改主机名 四、修改hosts映射 五、SSH免密登录 六、时钟同步 七、远程文件拷贝 1、从本机拷…
阅读更多...
剑指offer——二进制中1的个数

剑指offer——二进制中1的个数

目录 1. 题目描述2. 可能引起死循环的想法3. 改进后的代码4. 给面试官惊喜的代码 1. 题目描述 请实现一个函数&#xff0c;输入一个整数&#xff0c;输出该数二进制表示中1的个数。例如把9表示成二进制位1001&#xff0c;有2位是1&#xff0c;因此如果输入9&#xff0c;该函数输…
阅读更多...
Selenium图表自动化开篇

Selenium图表自动化开篇

目录 前言&#xff1a; 使用 Canvas 或者 SVG 渲染 选择哪种渲染器 代码触发 ECharts 中组件的行为 前言&#xff1a; 图表自动化一直以来是自动化测试中的痛点&#xff0c;也是难点&#xff0c;痛点在于目前越来越多公司开始构建自己的BI报表平台但是没有合适的自动化测试…
阅读更多...
Shell 学习笔记（三）-shell变量

Shell 学习笔记（三）-shell变量

Shell 语言是一种动态类型和弱类型语言, 因此,在Shell中无需显示地声明变量, 且变量的类型会根据不同的操作符而发生变化. 静态类型语言: 在程序编译期间就确定变量类型的语言, 如java, C等 动态类型语言: 在程序运行期间才确定变量类型的语言, 如PHP, Python等. 一 shell变量…
阅读更多...
设计模式--策略模式（Strategy Pattern）

设计模式--策略模式（Strategy Pattern）

策略模式&#xff08;Strategy Pattern&#xff09;是一种行为设计模式&#xff0c;它定义了一系列的算法&#xff0c;并将每一个算法封装起来&#xff0c;使它们可以互相替换&#xff0c;让算法独立于使用它的客户端。 策略模式主要包含以下几个角色&#xff1a; Strategy&a…
阅读更多...
高中信息技术—数据采集与编码（一）

高中信息技术—数据采集与编码（一）

计算机技术的应用&#xff0c;使得数据的处理方式发生了巨大的转变&#xff0c;要用计算机处理这些数据&#xff0c;需要对采集到的数据进行一定的转换。 采集方式 1.人工采集—观察、实验 2.机器采集 互联网—网络爬虫 传感器—自然信源 数字化 信息可用模拟信号或数字信号表…
阅读更多...
re:从0开始的CSS之旅 13. 文档流

re:从0开始的CSS之旅 13. 文档流

1. 三种基本机制 CSS盒子三种基本定位机制&#xff1a;普通流normal flow、浮动float、定位position 文档流&#xff08;标准流、普通流 normal flow&#xff09;&#xff1a;HTML文档中一些皆为盒子&#xff0c;而盒子在HTML文档中默认的显示标准&#xff0c;称为文档流 2. …
阅读更多...
最新文章

Copyright @ 2022~2023