C++——继承

embedded/2024/9/23 20:19:08/

学习C++对于初学者的第一挑战是前面的类和对象(封装)，而第二挑战则是继承与多态：

这可以说是面向对象的语言都要具备的三大特性；也是学习这些语言的“入门槛”；但由于C++出现较早，在这方面比其它语言学习起来要更为复杂(坑多多)，也使得一些初学者在学习过程中放弃了C++，这实在令人感叹......

目录

封装

继承

1概念 

2继承方式与访问限定符

3访问权限

4基类与派生类的赋值

​编辑 5继承中的作用域

6派生类的默认成员函数

6.1构造函数 

6.2拷贝函数

6.3赋值重载/析构函数

​编辑

7继承与友元

8继承与静态成员

9菱形继承与菱形虚拟继承

9.1单继承

9.2多继承 

9.3菱形继承 

9.4菱形虚拟继承 

9.5分析菱形虚拟继承模型

10继承的总结与反思

封装

1数据和方法放到一起，把想给访问的定义成共有，不想给你访问的定义成私有和保护

2一个类型放到另一个类型中，通过typedef成员函数调整，封装一个全新的类型：如迭代器：

而对于封装的具体学习在：类和对象中进行体现，这里就不详细叙述了，有兴趣就跳转我写的类和对象：http://t.csdnimg.cn/GpVAt 

继承

如果我们想创建以下几个类：

它们的成员变量都要有：name,age,address；如果按照通常的思路：要创建出四个类，每个类中写上一遍相同的成员变量；这不免会有些冗余：那有什么更好的方法吗？

我们可以用一个类：里面写上它们共同的成员变量（父类），在以继承的方式继承到各个类中（子类），子类中就继承了父类中的成员变量了，就不用自己去写；

这也是继承带来的优点之一

1概念 

 继承(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是子类，也称作派生类：

2继承方式与访问限定符

3访问权限

父类的成员，继承到派生类以后，访问权限怎么规定？

总结：

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

4基类与派生类的赋值

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。

这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

class Person
{
protected:string _name; // 姓名string _sex; // 性别int _age; // 年龄
};
class Student : public Person
{
public:int _No; // 学号
};
int main()
{Student st;// 1.子类对象可以赋值给父类对象/指针/引用Person p = st;Person& ref = st;Person* ptf= &st;return 0;
}

对应关系如下： 

public继承子类与父类的关系是：子类 is a 父类：每个子类对象都是一个特殊的父类对象！

父类对象能用指针指向子类当中父类继承的那部分，那我应该能对子类对象的继承成员进行修改：

 5继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（但在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 函数名相同就构成隐藏。

// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:void fun(){cout << "func()" << endl;}
};
class B : public A
{
public:void fun(int i){//A::fun();显示调用A的fun()cout << "func(int i)->" << i << endl;}
};
int main()
{B b;b.fun(10);return 0;
};

6派生类的默认成员函数

先来回忆回忆六大成员函数：

 派生类中的成员函数中会有哪些变化呢？

class Person
{
public:Person(const char* name): _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;}
protected:string _name; // 姓名
};class Student : public Person
{
public:// 父类+自己，父类的调用父类构造函数初始化（复用）Student(int num, const char* str, const char* name):Person(name)//要显示构造, _num(num), _str(str){cout << "Student()" << endl;}// s2(s1)Student(const Student& s):Person(s), _num(s._num), _str(s._str){}Student& operator=(const Student& s){if (this != &s){Person::operator=(s);//显示写_num = s._num;_str = s._str;}return *this;}// 子类的析构也会隐藏父类// 因为后续多态的需要，析构函数名字会被统一处理成destructor~Student(){// 显示写无法先子后父//Person::~Person();cout << _name << endl;cout << "~Student()" << endl;// 注意，为了析构顺序是先子后父，子类析构函数结束后会自动调用父类析构}protected:int _num;	 //学号string _str;// 父类成员，当成一个整体的一个自定义类型成员// 子类的成员(跟以前一样)// a、内置类型// b、自定义类型
};//与BB对象进行类比理解
class BB
{
public:BB(int num, const char* str, const char* name):_p(name),_num(num),_str(str){}
private:Person _p;int _num;string _str;
};int main()
{//类比构造//BB bb(1, "xxxx", "张三");//构造Student s1(1, "xxxx","张三");//拷贝Student s2(s1);//赋值Student s3(2, "yyy", "李四");s1 = s3;//析构Person p("李四");p.~Person();return 0;
}

6.1构造函数 

在子类中的父类成员，当成一个整体的一个自定义类型成员；其它规则与构造函数相同

构造继承过来的父类成员时要调用父类的构造函数来进行初始化：

初始化列表要显示写父类的构造：Person(name)，不写编译器会报错（如果是Person没有构造编译器也会报错）

你也可以理解成：子类继承父类成员是隐藏在子类中，构造父类成员时是希望你去复用父类的构造函数来方便初始化！！

6.2拷贝函数

一般情况下不写拷贝函数，编译器会为我们默认生成一个；涉及深拷贝才要写

派生类中的涉及基类的成员我们构造函数一样：父类的成员看成一个整体，去调用它的拷贝

那去调用父类的拷贝函数时参数要写什么呢？-->直接传入要拷贝的子类对象进行切片

6.3赋值重载/析构函数

赋值重载要显示写要注意：子类当中会隐藏父类的赋值重载，在写子类的赋值重载要注意显示写父类的赋值重载！！ 

同样，子类的析构其中会隐藏父类的析构(要显示调用！！)

原因：后续多态的需要，编译器会把析构函数统一写成destructor 

总结:

7继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

class Student;
class Person
{
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};class Student : public Person
{
protected:int _stuNum; // 学号
};void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;//不可访问
}int main()
{Person p;Student s;Display(p, s);
}

总结：父亲的朋友一定不是你的朋友！

8继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。

无论派生出多少个子类，都只有一个static成员实例：

class Person
{
public:Person() { ++_count; }
protected:string _name; // 姓名
public:static int _count; // 统计人的个数。
};
int Person::_count = 0;//静态成员在类外初始化class Student : public Person
{
protected:int _stuNum; // 学号
};class Graduate : public Student
{
protected:string _seminarCourse; // 研究科目
};int main()
{Student s1;Student s2;Student s3;Graduate s4;cout << "人数:" << Person::_count << endl;//几个子类就是几个countStudent::_count = 0;cout << "人数:" << Person::_count << endl;
}

创建子类，父类会被当成整体类型来调用它的默认构造：++count 

9菱形继承与菱形虚拟继承

C++对复用的方式体现在：1函数逻辑的复用；2模板；3继承

那继承有没有可能会出现继承多个父类来达到double继承？？ 有的：多继承~

而我们在上面介绍的继承方式全都是单继承：毕竟比较常用~

9.1单继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

9.2多继承 

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承 

 

比如：西红柿既可以是水果，有可以是蔬菜

9.3菱形继承 

 而在多继承中，又会出现一种特殊的多继承——菱形继承

比如：在职教师，同时在读博

菱形继承的出现，就会带来：1数据冗余；2数据二义性 

 以代码的方式来进行观察：

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";//Teacher和stduent都有变量name// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决a.Student::_name = "xxx";a.Teacher::_name = "yyy";
}

 

9.4菱形虚拟继承 

 解决菱形继承的方法——菱形虚拟继承：

多继承的继承方式改为：虚拟继承(加virtual关键字)

 

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._name << endl;return 0;
}

 

9.5分析菱形虚拟继承模型

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

菱形继承：

菱形虚拟继承：

此时：D对象继承的B,C中的变量——_a的位置发生了移动且只有一份；

而B,C里面原本是_a的位置现在存储着指针？这些代表着什么呢？

这里的A对象我们把它叫做：虚基类；在D对象中以公共的身份放到最下面被B,C访问

B和C的两个指针，指向的是一张表：叫虚基表。

虚基表中存的是偏移量：通过偏移量来计算虚基类的位置

 在STL库中也有对菱形虚拟继承的应用：

更复杂的菱形虚拟继承还有：

 

总结：在实践中可以设计使用多继承，但切记不要设计出菱形继承：太复杂，容易出错 

10继承的总结与反思

1. 很多人说C++语法复杂，其实多继承就是一个体现：

有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承
2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

3组合与继承

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

两者本质上都是一种复用

场景符合is-a的关系用继承；符合has-a的关系用组合；

两者都符合用组合：组合对内部实现细节不可见：低耦合

// Car和BMW Car和Benz构成is-a的关系
class Car {
protected:string _colour = "白色"; // 颜色
};class BMW : public Car {
public:void Drive() { cout << "好开-操控" << endl; }
};class Benz : public Car {
public:void Drive() { cout << "好坐-舒适" << endl; }
};// Tire和Car构成has-a的关系
class Tire {
protected:string _brand = "Michelin"; // 品牌size_t _size = 17; // 尺寸
};class Car {
protected:string _colour = "白色"; // 颜色string _num = "陕ABIT00"; // 车牌号Tire _t; // 轮胎
};

 以上便是继承相关的知识：有错误欢迎在评论区指正，谢谢！！


http://www.ppmy.cn/embedded/33080.html

相关文章

Maven3.9.6下载安装教程

Maven3.9.6下载安装教程

(/≧▽≦)/~┴┴ 嗨~我叫小奥 ✨✨✨ &#x1f440;&#x1f440;&#x1f440; 个人博客&#xff1a;小奥的博客 &#x1f44d;&#x1f44d;&#x1f44d;&#xff1a;个人CSDN ⭐️⭐️⭐️&#xff1a;Github传送门 &#x1f379; 本人24应届生一枚&#xff0c;技术和水平有…
阅读更多...
我用ADAU1467加5个ADAU1772，做20进10出的音频处理板（二十五）：滤波器-Shelving 滤波器

我用ADAU1467加5个ADAU1772，做20进10出的音频处理板（二十五）：滤波器-Shelving 滤波器

作者的话 ADAU1467是现阶段ADI支持最多通道的ADAU音频DSP&#xff0c;他配合外部的AD/DA&#xff0c;可以实现最多32路音频通道&#xff0c;接了一个小项目&#xff0c;我拿它做了一块20进10出的板&#xff0c;10个MIC/LINE输入,10个LINE IN输入&#xff0c;10个HPOUT&#xf…
阅读更多...
ES相关性计算原理

ES相关性计算原理

了解es搜索过程中的相关性计算原理&#xff0c;对判断当前应用场景是否适合使用es来召回相关结果至关重要。本篇博文尝试对es在每一个节点执行搜索时如何计算query和经由倒排索引查询到的对应字段文本之间的相关性做简要说明。 ES搜索过程&#xff08;节点层面&#xff09; ES…
阅读更多...
卸载conda及直接rm导致-bash: /root/anaconda3/bin/python3的解决

卸载conda及直接rm导致-bash: /root/anaconda3/bin/python3的解决

目录 卸载conda及直接rm导致-bash: /root/anaconda3/bin/python3的解决正常卸载非正常卸载导致 -bash: /root/anaconda3/bin/python3 参考资料 卸载conda及直接rm导致-bash: /root/anaconda3/bin/python3的解决 正常卸载 //首先使用conda安装anaconda清理工具 conda install …
阅读更多...
opengauss概述-基础知识篇-备考华为高斯

opengauss概述-基础知识篇-备考华为高斯

目录 &#x1f9e8;考前准备: &#x1f3a1;数据库操作语言 ✨OLTP和OLAP &#x1f3af;常用函数 &#x1f9f2;字符处理函数 关于 left 和 right 特别重点的字符串函数 &#x1f9f2;数字操作函数 关于 ceil 和 floor &#x1f9f2;时间和日期处理函数 &#x1f9f…
阅读更多...
批量抓取某电影网站的下载链接

批量抓取某电影网站的下载链接

思路&#xff1a; 进入电影天堂首页&#xff0c;提取到主页面中的每一个电影的背后的那个urL地址 a. 拿到“2024必看热片”那一块的HTML代码 b. 从刚才拿到的HTML代码中提取到href的值访问子页面&#xff0c;提取到电影的名称以及下载地址 a. 拿到子页面的页面源代码 b. 数据提…
阅读更多...
分割回文串（力扣131）

分割回文串（力扣131）

解题思路&#xff1a;仍就是上递归三部曲&#xff0c;但于此同时要明白此时的index就可以作为切割回文串的线了 具体代码如下&#xff1a; class Solution { private: vector<vector<string>> result; vector<string> path; // 放已经回文的子串 void back…
阅读更多...
深入浅出 BERT

深入浅出 BERT

Transformer 用于学习句子中的长距离依赖关系&#xff0c;同时执行序列到序列的建模。 它通过解决可变长度输入、并行化、梯度消失或爆炸、数据规模巨大等问题&#xff0c;比其他模型表现更好。使用的注意力机制是神经架构的一部分&#xff0c;使其能够动态突出显示输入数据的…
阅读更多...
最新文章

Copyright @ 2022~2023