类和对象-继承

师从黑马程序员

基本语法

有些类与类之间存在特殊的关系，例如：

定义这些类时，下一级别的成员除了拥有上一级的共性，还有自己的特性。

这时候我们就可以考虑继承技术，减少重复代码

语法：class 子类：继承方式  父类

子类也称为派生类          父类也称为 基类

#include <iostream>
#include <string>
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;}
};
//Pythin页面
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;}
};*///继承页面//公用页面
class BasePage
{
public:void header(){cout<<"首页、公开课、登录、注册...（公共头部）"<<endl;}void footer(){cout<<"帮助中心、交流合作、站内地图..."<<endl;}void left(){cout<<"Java\Python、C++...(公共分类列表)"<<endl;}};//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()
{cout<<"Java下载视频页面如下："<<endl;Java ja;ja.header();ja.footer();ja.left();ja.content();cout<<"--------------------"<<endl;cout<<"Java下载视频页面如下："<<endl;Python py;py.header();py.footer();py.left();py.content();cout<<"--------------------"<<endl;cout<<"C++下载视频页面如下："<<endl;Cpp cpp;cpp.header();cpp.footer();cpp.left();cpp.content();}int main()
{test01();system("pause");return 0;
}

继承方式

公共继承              保护继承            私有继承

#include <iostream>
#include <string>
using namespace std;//公共继承
class Base1
{
public:int m_A;
protected:int m_B;
private:int m_C;
};class Son1:public Base1
{
public:void func(){m_A=10;//父类中的公共权限成员 到子类中依然是公共权限m_B=10;//父类中的保护权限成员 到子类中依然是保护权限// m_C=10;//父类中的私有权限成员 子类访问不到}
};void test01()
{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:public Base2
{
public:void func(){m_A=10;//父类中的公共权限成员 到子类中依然是保护权限m_B=10;//父类中的保护权限成员 到子类中依然是保护权限// m_C=10;//父类中的私有权限成员 子类访问不到}
};void test02()
{Son2 s1;//s1.m_A=1000;//在Son2中 m_A变为保护权限 类外访问不到//s1.m_B=1000;//到了son1中m_B是保护权限 不可以访问
}//私有继承
class Base3
{
public:int m_A;
protected:int m_B;
private:int m_C;
};class Son3:public Base3
{
public:void func(){m_A=100;//父类中的公共权限成员 到子类中是私有权限m_B=100;//父类中的保护权限成员 到子类中是私有权限// m_C=100;//父类中的私有权限成员 子类访问不到}
};class GrandSon3:public Son3
{
public:void func(){//m_A=1000;//到了Son3中 m_A变为私有，即使是儿子，也是访问不到//m_B=1000;//到了Son3中 m_B变为私有，即使是儿子，也是访问不到}
};void test03()
{Son2 s1;//s1.m_A=1000;//在Son2中 m_A变为保护权限 类外访问不到//s1.m_B=1000;//到了son1中m_B是保护权限 不可以访问
}void test03()
{Son3 s1;//s1.m_A=1000;//到了Son3中 m_A变为私有，即使是儿子，也是访问不到//s1.m_B=1000;//到了Son3中 m_B变为私有，即使是儿子，也是访问不到}int main()
{test01();system("pause");return 0;
}

继承中的对象模型

开发人员命令提示工具查看对象模型的方法

1、跳转盘符     例：跳转F盘  则打出  F:

2、跳转文件路径 cd 具体路径下

3、查看命名   打出dir

4、 cl /d1 reportSingleClassLayout类名 文件名

#include <iostream>
#include <string>
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;
};void test01()
{//父类中所有非静态成员属性都会被子类继承下去//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但确实被继承下去了cout<<"size of Son="<<sizeof(Son)<<endl;//16
}int main()
{test01();system("pause");return 0;
}

继承中构造和析构顺序

子类继承父类后，当创建 子类对象，也会调用父类的构造函数

#include <iostream>
#include <string>
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()
{//Base b;//继承中的构造和析构顺序如下：//先构造父类，再构造子类，析构的顺序与构造的顺序相反Son s;
}int main()
{test01();system("pause");return 0;
}

继承同名成员处理方式

访问子类同名成员  直接访问即可

访问父类同名成员 需要加作用域

#include <iostream>
#include <string>
using namespace std;class Base
{
public:Base(){m_A=100;}void func(){cout<<"Base -func()调用"<<endl;}void func(int a){cout<<"Base -func(int)调用"<<endl;}int m_A;};class Son:public Base
{
public:Son(){m_A=200;}void func(){cout<<"Son -func()调用"<<endl;}int m_A;
};//同名成员属性处理
void test01()
{Son s;cout<<"Son下 m_A= "<<s.m_A<<endl;//200//如果通过子类对象 访问到父类中同名成员，需要加作用域cout<<"Base下 m_A= "<<s.Base::m_A<<endl;//100}//同名成员函数处理
void test02()
{Son s;s.func();//直接调用 调用是子类中的同名成员s.Base::func();//调用是父类中的同名成员//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数//s.func(100);wrong//如果想访问到父类中被隐藏的同名成员函数，需要加作用域s.Base::func(100);
}int main()
{//test01();test02();system("pause");return 0;
}

继承同名静态成员处理方式

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员  直接访问即可

访问父类同名成员 需要加作用域

#include <iostream>
#include <string>
using namespace std;class Base
{
public:static int m_A;static void func(){cout<<"Base -static void func()"<<endl;}static void func(int a){cout<<"Base -static void func()"<<endl;}
};int Base::m_A = 100;class Son : public Base
{
public:static int m_A;static void func(){cout<<"Son -static void func()"<<endl;}
};int Son::m_A = 200;// 同名静态成员属性
void test01()
{//1、通过对象访问cout<<"通过对象访问"<<endl;Son s;cout << "Son 下m_A=" << s.Son::m_A << endl; // 访问 Son 类的静态变量cout << "Base 下m_A=" << s.Base::m_A << endl; // 访问 Base 类的静态变量//2、通过类名访问cout<<"通过类名访问"<<endl;cout<<"Son 下m_A ="<<Son::m_A<<endl;//第一个::代表通过类名各方式访问  第二个::代表访问父类作用域下cout<<"Base 下m_A ="<<Son::Base::m_A<<endl;}//同名静态成员函数
void test02()
{//1、通过对象访问Son s;s.func();s.Base::func();//2、通过类名访问cout<<"通过类名访问"<<endl;Son::func();Son::Base::func();//子类出现和父类同名静态函数，也会隐藏父类中所有同名成员函数//如果想访问父类中被隐藏同名成员，需要加作用域Son::Base::func(100);
}int main()
{test01();system("pause");return 0;
}

多继承语法

语法：class 子类：继承方式  父类1，继承方式  父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

#include <iostream>
#include <string>
using namespace std;class Base1
{
public:Base1(){m_A=100;}int m_A;
};class Base2
{
public:Base2(){m_A=200;}int m_A;
};//子类 需要继承Base1和Base2
class Son : public Base1,public Base2
{
public:Son(){m_C=300;m_D=400;}int m_C;int m_D;};void test01()
{Son s;cout<<"sizeof  Son ="<<sizeof(s)<<endl;//当父类中出现同名成员，需要加作用域区分cout<<"Base1::m_A= "<<s.Base1::m_A<<endl;cout<<"Base2::m_A= "<<s.Base2::m_A<<endl;}int main()
{test01();system("pause");return 0;
}

菱形继承（钻石继承）

概念：

两个派生类继承同一个基类

又有某个类同时继承两个派生类

#include <iostream>
#include <string>
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=18;st.Tuo::m_Age=28;//当菱形继承，两个父类拥有相同数据，需要加以作用域区分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/734641.shtml

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

相关文章

RAG模型的挑战与解决方案概览

RAG模型的挑战与解决方案概览

RAG模型的挑战与解决方案概览 背景: 提取增强生成(RAG)模型通过利用存储在文档中的外部知识来提高生成文本的准确性和相关性&#xff0c;显示出巨大潜力。但这些模型面临着多个挑战&#xff0c;如低质量检索、覆盖率不足、上下文条件化困难、幻觉和制造问题、解释和可解释性缺…
阅读更多...
加密流量分类torch实践4：TrafficClassificationPandemonium项目更新

加密流量分类torch实践4：TrafficClassificationPandemonium项目更新

加密流量分类torch实践4&#xff1a;TrafficClassificationPandemonium项目更新 更新日志 代码已经推送开源至露露云的github&#xff0c;如果能帮助你&#xff0c;就给鼠鼠点一个star吧&#xff01;&#xff01;&#xff01; 3/10号更新 流量预处理更新 增加了基于splitCa…
阅读更多...
misc49

misc49

下载附件是个txt文件&#xff0c;打开发现是个压缩包的头 后缀改成zip后打开 base解码无果&#xff0c;我们尝试字母解码 然后音符解码得到 ❀✿✼❇❃❆❇✿❁❇✻✿❀✾✿✻❀❊❆❃❀❊✻❅❀❄✼❂❊❊✾❇❁✽✽✼❁❂❀❀❀❉❃❂❀❉❃❂❊❊✾✼✻✻❀❆✻✻❀❀✻✻✿…
阅读更多...
round四舍五入在python2与python3版本间区别

round四舍五入在python2与python3版本间区别

round()方法返回数值的小数点四舍五入到n个数字。 语法 以下是round()方法的语法&#xff1a; round( x ,n) 参数 x --这是一个数值&#xff0c;表示需要格式化的数值 n --这也是一个数值,表示小数点后保留多少位 返回值 该方法返回 数值x 的小数点四舍五入到n个数字 …
阅读更多...
spark 总结

spark 总结

1.spark 配置文件 spark-default.conf spark.yarn.historyServer.address xiemeng-01:18080 spark.history.port18080 hive-site.xml <configuration><property><name>javax.jdo.option.ConnectionURL</name> </property><property>&…
阅读更多...
Rust 开源线性代数库 nalgebra_linsys

Rust 开源线性代数库 nalgebra_linsys

nalgebra_linsys 是 Rust 中 nalgebra 生态系统的一部分&#xff0c;它专注于线性系统的求解。这个库提供了用于解决线性方程组、最小二乘问题以及进行线性代数系统分析的工具。 nalgebra_linsys 库建立在 nalgebra 库的基础上&#xff0c;nalgebra 本身是一个强大的线性代数库…
阅读更多...
支持向量机(SVM)算法基本原理skearn实现

支持向量机(SVM)算法基本原理skearn实现

1 什么是支持向量机 支持向量机&#xff08;Support Vector Machine&#xff0c;简称SVM&#xff09;是一种用来解决二分类问题的机器学习算法&#xff0c;它通过在样本空间中找到一个划分超平面&#xff0c;将不同类别的样本分开&#xff0c;同时使得两个点集&#xff08;两个…
阅读更多...
spring三种配置方式总结

spring三种配置方式总结

1 XML方式配置总结 所有内容写到xml格式配置文件中声明bean通过<bean标签<bean标签包含基本信息&#xff08;id,class&#xff09;和属性信息 <property name value / ref引入外部的properties文件可以通过<context:property-placeholderIoC具体容器实现选择Class…
阅读更多...
C#位移运算，位运算

C#位移运算，位运算

//位运算 与& 或| 非~ 异或^ int x 10; //00001010 int y 5; //00000101 &:逐位进行与运算&#xff1a;1&1 1 1&0 0 0&0 0 int result_and x & y; //0 |:逐位进行或运算&#xff1a…
阅读更多...
Python语言例题集（008）

Python语言例题集（008）

#!/usr/bin/python3 #建立链表类和遍历此链表 class Node(): def init(self,dataNone): self.datadata self.nextNone class LinkedList(): def init(self): self.headNone def printList(self):ptrself.headwhile ptr:print(ptr.data)ptrptr.nextlinkLinkedList() link.he…
阅读更多...
使用css结合js实现html文件中的双行混排

使用css结合js实现html文件中的双行混排

此前写过一个使用flex布局实现html文件中的双行混排&#xff0c;但是感觉效果不佳。经过几天思考&#xff0c;我认为双行混排的要点其实是两个&#xff1a; 1、正文和批注的文字大小不同&#xff1b; 2、正文和批注的行距相互配合进行设定。 正文和批注的文字大小及行距都可…
阅读更多...
网络层转发分组的过程

网络层转发分组的过程

分组转发都是基于目的主机所在网络的&#xff0c;这事因为互联网上的网络数远小于主机数&#xff0c;这样可以极大的压缩转发表的大小。当分组到达路由器后&#xff0c;路由器根据目的IP地址的网络地址前缀查找转发表&#xff0c;确定下一跳应当到哪个有路由器。因此&#xff0…
阅读更多...
OpenHarmony下musl编译工具链普法

OpenHarmony下musl编译工具链普法

OpenHarmony下musl编译工具链普法 引言 欠的债总是要还的&#xff0c;这不前面欠的关于OpenHarmony下musl相关的还是要还的。这里我对其中的相关知识点&#xff0c;梳理&#xff0c;归纳重新消化下&#xff01; 一.GCC/Clang/LLVM的区别与联系 说实话&#xff0c;这块我现在都…
阅读更多...
【C语言】深入理解指针（扩展）

【C语言】深入理解指针（扩展）

一、回调函数是什么 回调函数就是一个通过函数指针调用的函数。 如果你把函数的指针&#xff08;地址&#xff09;做为参数传递给另一个函数&#xff0c;当这个歌指针被用来调用其所指向的函数时&#xff0c;被调用的函数就回调函数。回调函数不是又该函数的实现方直接调用&a…
阅读更多...
当量化私募投资总监能学到什么？

当量化私募投资总监能学到什么？

我的情况更新 ​我是美国电子工程背景毕业的。在华尔街第一份实习是在E3做手工t0的proprietary trading&#xff0c;被刷下来之后就一直在帮顶级的对冲基金打杂当助理。所以当初决定回国一展身手&#xff0c;并且写下了破百万阅读的&#xff1a; 在私募做量化研究半年能学到什…
阅读更多...
3级考题（2）（c++）

3级考题（2）（c++）

#5062. 找和为K的两个元素 题目描述 在一个长度为n&#xff08;n<1000&#xff09;的整数序列中&#xff0c;判断是否存在某两个元素之和为k。 输入格式 第一行输入整数序列的长度n和k&#xff0c;n和k以空格间隔。 第二行输入整数序列中的n个整数&#xff0c;整数以空…
阅读更多...
基于神经网络的偏微分方程求解器再度取得突破,北大字节的研究成果入选Nature子刊

基于神经网络的偏微分方程求解器再度取得突破,北大字节的研究成果入选Nature子刊

目录 一.引言:神经网络与偏微分方程 二.如何基于神经网络求解偏微分方程 1.简要概述 2.基于神经网络求解偏微分方程的三大方向 2.1数据驱动 基于CNN 基于其他网络 2.2物理约束 PINN 基于 PINN 可测量标签数据 2.3物理驱动(纯物理约束) 全连接神经网路(FC-NN) CN…
阅读更多...
保姆级讲解字符串函数（下篇）

保姆级讲解字符串函数（下篇）

目录 strtok的使用 strerror的使用 strstr的使用和函数模拟实现 strstr的使用 strstr函数模拟实现 接上篇&#xff1a;保姆级讲解字符串函数&#xff08;上篇&#xff09;&#xff0c;我们接着把剩下三个函数讲解完&#xff0c;继续跟着我的步伐一起学习呀. strtok的使用 …
阅读更多...
从 Language Model 到 Chat Application：对话接口的设计与实现

从 Language Model 到 Chat Application：对话接口的设计与实现

作者&#xff1a;网隐 RTP-LLM 是阿里巴巴大模型预测团队开发的大模型推理加速引擎&#xff0c;作为一个高性能的大模型推理解决方案&#xff0c;它已被广泛应用于阿里内部。本文从对话接口的设计出发&#xff0c;介绍了业界常见方案&#xff0c;并分享了 RTP-LLM 团队在此场景…
阅读更多...
ARM中多寄存内存访问概念和栈的种类和应用

ARM中多寄存内存访问概念和栈的种类和应用

多寄存器内存访问指令 多寄存器内存访问指令 MOV R1,#1 MOV R2,#2 MOV R3,#3 MOV R4,#4 MOV R11,#0x40000020 STM R11,{R1-R4} 将R1-R4寄存器中的数据存储到内存以R11为起始地址的内存中 LDM R11,{R6-R9} 将内存中以R11为起始地址的数据读取到R6-R9寄存器中 当寄存器…
阅读更多...
最新文章

Copyright @ 2022~2023