继承【C++】

文章目录

  • 继承的概念
  • 继承的定义
    • 继承方式和访问限定符
      • 继承基类成员访问方式的变化
    • 默认继承方式
  • 基类和派生类对象赋值转换
  • 继承中的作用域
  • 派生类的默认成员函数
  • 继承与友元
  • 静态成员
  • 菱形继承及菱形虚拟继承
    • 继承的方式
  • 菱形虚拟继承
  • 菱形虚拟继承原理

继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "peter";int _age = 18;
};class  Student :public Person
{
protected:int _stuid; //学号
};class Teacher : public Person
{
protected :int _jobid;//工号
};
int main()
{Student s;Teacher t;s.Print();t.Print();return 0;
}

继承后，父类Person的成员，包括成员函数和成员变量，都会变成子类的一部分，也就是子类Student和Teacher复用了父类Person的成员。

继承的定义

Person是父类，也称作基类。Student是子类，也称作派生类

在这里插入图片描述

继承方式和访问限定符

访问限定符有以下三种：public访问、protected访问、private访问

继承的方式也有类似的三种：public继承、protected继承、private继承

继承基类成员访问方式的变化

基类当中被不同访问限定符修饰的成员，以不同的继承方式继承到派生类当中后，该成员最终在派生类当中的访问方式将会发生变化。

在这里插入图片描述

总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。
    这里所说的不可见，从语法上限制访问(类里面和类外面都不能用)。
    跟private访问限定符不一样，private访问限定符类外面不能使用，类里面可以使用
//基类
class Person
{
private:string name = "张三";
};
//派生类
class Student :public  Person
{
public:void Print(){//在派生类当中访问基类的private成员cout << _name << endl;//error}
protected:int _stuid; // 学号
};

上述代码中 ，Student类继承了Person类，但是无法在Student类当中访问Person类当中的private成员_name。如果需要在派生类中能访问，就将private修改为protected

  1. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

  2. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public> protected> private。

  3. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

  4. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

默认继承方式

在使用继承的时候也可以不指定继承方式，使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。

//基类
class Person
{
public:string _name = "张三"; //姓名
};
//派生类
class Student : Person //默认为private继承
{
protected:int _stuid;   //学号
};

在关键字为class的派生类当中，所继承的基类成员_name的访问方式变为private。

//基类
class Person
{
public:string _name = "张三"; //姓名
};
//派生类
struct Student : Person //默认为public继承
{
protected:int _stuid;   //学号
};

在关键字为struct的派生类当中，所继承的基类成员_name的访问方式仍为public。

基类和派生类对象赋值转换

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

//基类
class Person
{
public:string _name; //姓名string _sex;  //性别int _age;     //年龄
};//派生类
class Student : public Person  
{
protected:int _stuid;   //学号
};int main()
{Student s;Person p = s; //派生类对象赋值给基类对象Person* ptr = &s;//派生类对象赋值给基类指针Person& ref = s; //派生类对象赋值给基类引用return 0;
}

派生类对象赋值给基类对象图示：

在这里插入图片描述
注意：基类对象不能赋值给派生类对象。

继承中的作用域

在继承体系中的基类和派生类都有独立的作用域。如果子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义

例如：

//父类
class Person
{
protected:int _num = 111;
};
//子类
class Student : public Person
{
public: void fun(){cout << _num << endl;}
protected:int _num = 999;
};
int main()
{Student s;s.fun();//访问子类的_numreturn 0;
}

如果需要访问父类当中的_num成员，使用作用域限定符进行指定访问。

//父类
class Person
{
protected:int _num = 111;
};
//子类
class Student : public Person
{
public: void fun(){cout << Person::_num << endl;}
protected:int _num = 999;
};
int main()
{Student s;s.fun();//访问子类的_numreturn 0;
}

下面的代码，调用成员函数fun时将调用子类当中的fun，如果需要调用父类当中的fun，则使用作用域限定符指定类域。

//父类
class Person
{
public:void fun(int x){cout << x << endl;}
};
//子类
class Student : public Person
{
public:void fun(double x){cout << x << endl;}
};
int main()
{Student s;s.fun(3.14);       //直接调用子类当中的成员函数funs.Person::fun(20); //指定调用父类当中的成员函数funreturn 0;
}

上述代码，父类中的fun和子类中的fun不是构成函数重载，构成函数重载需要两个函数在同一作用域，而此时这两个fun函数并不在同一作用域。为了避免类似问题，实际在继承体系当中最好不要定义同名的成员。

隐藏： 父子类域中，成员函数的函数名相同就构成隐藏，不用管函数参数，只需要看函数名即可

派生类的默认成员函数

默认成员函数，即我们不写编译器会自动生成的函数，类当中的默认成员函数有以下六个：

在这里插入图片描述

//基类
class Person
{
public://构造函数Person(const string& name = "Peter"):_name(name){cout << "Person()" << endl;}//拷贝构造Person(const  Person& p):_name(p._name){cout << "Person(const Person& p)" << endl;}//赋值Person& operator= (const  Person& p){cout << "Person& operator=(const Person& p)" << endl;if (this != &p){_name = p._name;}return *this;}~Person(){cout << "~Person()" << endl;}
private:string _name;
};//派生类
class Student : public Person
{
public://默认构造函数//先父后子Student(const string name = "张三", int id = 0):Person(name)//匿名对象 ，调用基类的构造函数初始化基类的成员, _id(id){}//拷贝构造Student(const Student& s):Person(s), _id(s._id){}//赋值Student& operator= (const Student& s){if (this != &s){Person::operator=(s);//?_id = s._id;}return *this;}~Student(){//显示调用父类析构，无法保证先子后父// Person::~Person();//在子类析构函数完成,就调用父类析构,这样就保证了先子后父delete _ptr;}
private:int _id;int* _ptr = new int;
};
int main()
{Student s1;Student s2(s1);Student s3("李四", 1);s1 = s3;return 0;
}

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

  5. 派生类对象初始化先调用基类构造再调派生类构造。

  6. 派生类对象析构清理先调用派生类析构再调基类的析构。

  7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

注意：
1、派生类和基类的赋值运算符重载函数，函数名相同，但是在不同作用域，构成隐藏，所以在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。
2、由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。
3、在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

继承与友元

友元关系不能继承
即基类的友元可以访问基类的私有和保护成员，但是不能访问派生类的私有和保护成员。

#include <iostream>
#include <string>
using namespace std;
class Student;
class Person
{
public://声明Display是Person的友元friend void Display(const Person& p, const Student& s);
protected:string _name; //姓名
};
class Student : public Person
{
protected:int _id; //学号
};
void Display(const Person& p, const Student& s)
{cout << p._name << endl; //可以访问cout << s._id << endl; //err
}
int main()
{Person p;Student s;Display(p, s);return 0;
}

如果Display函数需要访问派生类Student的私有和保护成员，在派生类Student当中进行友元声明。

//有元关系不能继承
class Student;
class Person
{
public: friend void Display(const Person & p, const Student & s);
protected:string _name;
};class Student :public Person
{friend void Display(const Person& p, const Student& s);
protected :int _id;
};void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._id << endl;}int main()
{Person p;Student s;Display(p, s);return 0;
}

静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例

//基类
class Person
{
public:Person(){_count++;}
protected :string _name;
public:static int _count;
};int Person::_count = 0;
//派生类
class Student : public Person
{
protected :string _seminarCourse; //研究科目
};int main()
{Person p;Student s1;Student s2;cout << Person::_count << endl;return 0;
}

菱形继承及菱形虚拟继承

继承的方式

单继承：一个子类只有一个直接父类时称这个继承关系为单继承。
在这里插入图片描述
多继承：一个子类有两个或两个以上直接父类时称这个继承关系为多继承。
在这里插入图片描述

菱形继承：菱形继承是多继承的一种特殊情况。
在这里插入图片描述

菱形继承有数据冗余和二义性的问题。

//基类
class Person
{
public:string _name;
};
//派生类
class Student :public Person
{protected:int _num;
};
class Teacher :public Person
{protected:int _id;
};//菱形继承
class Assistant :public Student, public Teacher
{
protected:string _majorCourse; //主修课程
};int main()
{Assistant a;//a._name = "peter";//errreturn 0;
}

Assistant对象是多继承的Student和Teacher，而Student和Teacher当中都继承了Person，因此Student和Teacher当中都有_name成员，直接访问Assistant的_name成员，编译器不知道访问哪一个，会报错

解决方案：

//显示指定访问哪个父类的成员
a.Student::_name = "张三";
a.Teacher::_name = "李四";

上述解决方案可以解决二义性问题，但是不能解决数据冗余，在Assistant的对象在Person成员始终会存在两份。
在这里插入图片描述

菱形虚拟继承

为了解决菱形继承的二义性和数据冗余问题，出现了虚拟继承。
在Student和Teacher继承Person是使用虚拟继承，即可解决问题。
在这里插入图片描述

#include <iostream>
#include <string>
using namespace std;
class Person
{
public:string _name; //姓名
};
class Student : virtual public Person //虚拟继承
{
protected:int _num; //学号
};
class Teacher : virtual public Person //虚拟继承
{
protected:int _id; //职工编号
};
class Assistant : public Student, public Teacher
{
protected:string _majorCourse; //主修课程
};
int main()
{Assistant a;a._name = "peter";cout << a.Student::_name << endl;cout << a.Teacher::_name << endl;//解决了数据冗余cout << &a.Student::_name << endl;cout << &a.Teacher::_name << endl;return 0;
}

此时就可以直接访问Assistant对象的_name成员了，解决了二义性问题

菱形虚拟继承原理

class A
{
public:int _a;
};class B :public A
{
public : int _b;
};
class C :public A
{
public:int _c;
};class D :public B ,public C 
{
public:int _d;
};int main()
{D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0;
}

在这里插入图片描述
D类对象当中各个成员在内存当中的分布情况如下：
在这里插入图片描述
菱形继承的数据冗余和二义性，本质上是D类对象当中含有两个_a成员。

如果使用菱形虚拟继承时，菱形继承当中D类对象的各个成员在内存当中的分布情况。

#include <iostream>
using namespace std;
class A
{
public:int _a;
};
class B : virtual public A
{
public:int _b;
};
class C : virtual public A
{
public:int _c;
};
class D : public B, public C
{
public:int _d;
};
int main()
{D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0;
}

在这里插入图片描述
其中D类对象当中的_a成员被放到了最后，而在原来存放两个_a成员的位置变成了两个指针，这两个指针叫虚基表指针，它们分别指向一个虚基表。
虚基表中包含两个数据，第一个数据是为多态的虚表预留的存偏移量的位置（这里我们不必关心），第二个数据就是当前类对象位置距离公共虚基类的偏移量。

也就是说，这两个指针经过一系列的计算，最终都可以找到成员_a
在这里插入图片描述

若是将D类对象赋值给B类对象，在这个切片过程中，就需要通过虚基表中的第二个数据找到公共虚基类A的成员，得到切片后该B类对象在内存中仍然保持这种分布情况。

D d;
B b = d; //切片行为

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

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

相关文章

自建音乐服务器Navidrome之二

自建音乐服务器Navidrome之二

6 准备音乐资源 可选 Last.fm Lastfm是 Audioscrobbler 音乐引擎设计团队的旗舰产品&#xff0c;以英国为总部的网络电台和音乐社区。有遍布232个国家超过1500万的活跃听众。据说有6亿音乐资源。 docker-compose.yml 配置 Navidrome 可以从 Last.fm 和 Spotify 获取专辑信息和…
阅读更多...
用 ChatGPT 写代码太省时间了

用 ChatGPT 写代码太省时间了

几个月前&#xff0c;我们聊过陶哲轩使用 ChatGPT 辅助解决数学问题。当时&#xff0c;他觉得虽然测试结果不太令人满意&#xff0c;但也并没有对 ChatGPT 持完全否定的态度。他觉得&#xff0c;像 ChatGPT 这类大型语言模型在数学中可以用来做一些半成品的语义搜索工作&#x…
阅读更多...
iOS开发Swift-4-IBAction,group,音乐播放器-木琴App

iOS开发Swift-4-IBAction,group,音乐播放器-木琴App

1.使用素材创建木琴App的UI。 2.连接IBAction。 其余按钮直接拖拽到play里边。 当鼠标置于1处时2处显示如图&#xff0c;表示成功。当用户按下任一按钮都会触发play中的内容。 3.将7个按钮的View中的Tag值分别调为1、2、3、4、5、6、7. 4.将音频文件拖入项目文件中。 Create gr…
阅读更多...
VSCode连接服务器

VSCode连接服务器

Pycharm连接服务器参考我的另一篇文章Pycharm远程连接服务器_pycharm进入服务器虚拟环境终端_Jumbo星的博客-CSDN博客 本质上Pycharm和VSCode都只是IDE&#xff0c;没有什么好坏之分。但是因为Pycharm连接服务器&#xff08;准确来说是部署&#xff09;需要买professional。而…
阅读更多...
Kubernetes技术--k8s核心技术Controller控制器

Kubernetes技术--k8s核心技术Controller控制器

1.Controller概述 Controller是在集群上管理和运行容器的对象。是一个实际存在的对象。 2.pod和Controller之间的关系 pod通过controller实现应用的运维，包括伸缩、滚动升级等操作。 这里pod和controller通过label标签来建立关系。如下所示: 3.Deployment控制器应用场景 -1:…
阅读更多...
MySQL 8.1.0 推出 InnoDB Cluster 只读副本

MySQL 8.1.0 推出 InnoDB Cluster 只读副本

全面了解 8.1.0 版本新功能&#xff1a;InnoDB Cluster 只读副本的相关操作。 作者&#xff1a;Miguel Arajo 高级软件工程师 / Kenny Gryp MySQL 产品总监 本文来源&#xff1a;Oracle MySQL 官网博客 * 爱可生开源社区出品。 前言 MySQL 的第一个 Innovation 版本 8.1.0 已…
阅读更多...
【小沐学Python】UML类图的箭头连线关系总结（python+graphviz）

【小沐学Python】UML类图的箭头连线关系总结（python+graphviz）

文章目录 1、简介1.1 类图1.2 Graphviz 2、Graphviz2.1 安装2.2 命令行测试2.3 python测试 3、关系3.1 实现3.2 泛化3.3 关联3.4 依赖3.5 聚合3.6 组合 结语 1、简介 UML&#xff08;unified modeling language&#xff0c;统一建模语言&#xff09;是一种常用的面向对象设计的…
阅读更多...
排序算法问题

排序算法问题

给你一个整数数组 nums&#xff0c;请你将该数组升序排列。 示例 1&#xff1a; 输入&#xff1a;nums [5,2,3,1] 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&#xff1a;nums [5,1,1,2,0,0] 输出&#xff1a;[0,0,1,1,2,5] 代码如下&#xff1a; 1.插入排序(简…
阅读更多...
【Grasshopper基础15】“右键菜单似乎不太对劲”

【Grasshopper基础15】“右键菜单似乎不太对劲”

距离上一篇文章已经过去了挺久的&#xff0c;很长时间没有写GH基础部分的内容了&#xff0c;原因其一是本职工作太忙了&#xff0c;进度也有些落后&#xff0c;白天工作累成马&#xff0c;回家只想躺着&#xff1b;其二则是感觉GH基础系列基本上也介绍得差不多了&#xff0c;电…
阅读更多...
Linux C++ 海康摄像头获取过车信息

Linux C++ 海康摄像头获取过车信息

代码 void CALLBACK MessageCallback(LONG lCommand, NET_DVR_ALARMER *pAlarmer, char *pAlarmInfo, DWORD dwBufLen, void *pUser) {printf("enter MessageCallback---------------------->\n");int i;NET_DVR_ALARMINFO_V30 struAlarmInfo;memcpy(&struAl…
阅读更多...
浅谈红队资产信息收集经验

浅谈红队资产信息收集经验

文章目录 子公司资产收集备案号|官网收集子域名|ip收集fofa灯塔ARLX情报社区 资产确认目录扫描Google Hacking绕过CDNnmap端口扫描参数技巧其他常用工具 子公司资产收集 红蓝对抗中往往只会给你目标企业的名称&#xff0c;以及对应的靶标系统地址&#xff0c;而很少有直接从靶标…
阅读更多...
Python大数据处理利器之Pyspark详解

Python大数据处理利器之Pyspark详解

摘要&#xff1a; 在现代信息时代&#xff0c;数据是最宝贵的财富之一&#xff0c;如何处理和分析这些数据成为了关键。Python在数据处理方面表现得尤为突出。而pyspark作为一个强大的分布式计算框架&#xff0c;为大数据处理提供了一种高效的解决方案。本文将详细介绍pyspark…
阅读更多...
Mac“其他文件”存放着什么？“其他文件”的清理方法

Mac“其他文件”存放着什么？“其他文件”的清理方法

很多Mac用户在清理磁盘空间时发现&#xff0c;内存占用比例比较大的除了有iCloud云盘、应用程序、影片、音频、照片等项目之外&#xff0c;还有一个“其他文件”的项目磁盘占用比也非常大&#xff0c;想要清理却无从下手。那么Mac“其他文件”里存放的是什么文件&#xff1f;我…
阅读更多...
Anaconda虚拟环境下导入opencv

Anaconda虚拟环境下导入opencv

文章目录 解决方法测试 解决方法 1、根据自己虚拟环境对于的python版本与电脑对应的位长选择具体的版本&#xff0c;例如python3.9选择cp39&#xff0c;64位电脑选择64 下载地址&#xff1a;资源地址 若是不确定自己虚拟环境对应的python版本&#xff0c;可以输入下列命令&…
阅读更多...
【LeetCode】剑指 Offer ＜二刷＞（1）

【LeetCode】剑指 Offer ＜二刷＞（1）

目录 前言&#xff1a; 题目&#xff1a;剑指 Offer 03. 数组中重复的数字 - 力扣&#xff08;LeetCode&#xff09; 题目的接口&#xff1a; 解题思路&#xff1a; 代码&#xff1a; 过啦&#xff01;&#xff01;&#xff01; 写在最后&#xff1a; 前言&#xff1a; …
阅读更多...
【办公自动化】使用Python批量处理Excel文件并转为csv文件

【办公自动化】使用Python批量处理Excel文件并转为csv文件

&#x1f935;‍♂️ 个人主页&#xff1a;艾派森的个人主页 ✍&#x1f3fb;作者简介&#xff1a;Python学习者 &#x1f40b; 希望大家多多支持&#xff0c;我们一起进步&#xff01;&#x1f604; 如果文章对你有帮助的话&#xff0c; 欢迎评论 &#x1f4ac;点赞&#x1f4…
阅读更多...
Linux知识点 -- Linux多线程（四）

Linux知识点 -- Linux多线程（四）

Linux知识点 – Linux多线程&#xff08;四&#xff09; 文章目录 Linux知识点 -- Linux多线程&#xff08;四&#xff09;一、线程池1.概念2.实现3.单例模式的线程池 二、STL、智能指针和线程安全1.STL的容器是否是线程安全的2.智能指针是否是线程安全的 三、其他常见的各种锁…
阅读更多...
微服务dubbo和nexus

微服务dubbo和nexus

微服务是一种软件开发架构风格&#xff0c;它将一个应用程序拆分成一组小型、独立的服务&#xff0c;每个服务都可以独立部署、管理和扩展。每个服务都可以通过轻量级的通信机制&#xff08;通常是 HTTP/REST 或消息队列&#xff09;相互通信。微服务架构追求高内聚、低耦合&am…
阅读更多...
vue声明周期

vue声明周期

1.在created中发送数据 async created(){ const resawait axios.get("url) this.listres.data.data } 2.在mounted中获取焦点 mounted(){ document.querySelector(#inp).focus()
阅读更多...
视频图像处理算法opencv在esp32及esp32s3上面的移植，也可以移植openmv

视频图像处理算法opencv在esp32及esp32s3上面的移植，也可以移植openmv

opencv在esp32及esp32s3上面的移植 Opencv简介 OpenCV是一个基于Apache2.0许可&#xff08;开源&#xff09;发行的跨平台计算机视觉和机器学习软件库&#xff0c;可以运行在Linux、Windows、Android和Mac OS操作系统上&#xff0c;它轻量级而且高效——由一系列 C 函数和少量…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023