第六层：继承

已于 2023-01-21 23:46:56 修改
阅读量1.2k 收藏 12
点赞数 23
分类专栏： C++爬塔日记 文章标签： c++ 开发语言
于 2023-01-21 15:32:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72867798/article/details/128745740
版权

文章目录

🎉welcome🎉
✒️博主介绍：一名大一的智能制造专业学生，在学习C/C++的路上会越走越远，后面不定期更新有关C/C++语法，数据结构，算法，Linux，ue5使用，制作游戏的心得，和大家一起共同成长。
✈️C++专栏：C++爬塔日记
😘博客制作不易，👍点赞+⭐收藏+➕关注

前情回顾

在第五层中，我遇到了在C++中第二个重载，操作符重载，它与函数重载差别很大，对于操作符重载，本质其实为函数，只是将函数名换成了C++提供给程序员特定的名字，同时第五层的力量也掌握到了，要踏入第六层了…

继承

当脚接触到第六层的地面的时候，那到声音随之飘来：“这第六层可不简单，它的力量是面向对象的第二大特性——继承，希望你不要让我失望…”

继承的作用

继承是面向对象的三大特性之一，在C++中，有些类的关系如下图：
在这里插入图片描述
可以发现，这些类，下级的成员除了会拥有上级的特性，还拥有自己的特性，这个时候如果一个一个封装，会造成很多重复的代码，这里就可以用继承的力量，减少大量的重复代码。

继承的基本语法

在浏览一些网站的时候，比如：csdn、牛客，都会发现，它们都有公共的头部和底部，那我自己的csdn主页来说：
在这里插入图片描述
在这里插入图片描述
不一样的是中间的内容不相同，那如果用普通方法打印一下这个网页的基本内容会是什么样的？

#include<iostream>
using namespace std;

class A1
{
public:
	void head()
	{
		cout << "博客主页头部" << endl;
	}
	void middle()
	{
		cout << "A1的博客内容" << endl;
	}
	void  bottom()
	{
		cout << "博客主页底部" << endl;
	}
};
class A2
{
public:
	void head()
	{
		cout << "博客主页头部" << endl;
	}
	void middle()
	{
		cout << "A2的博客内容" << endl;
	}
	void  bottom()
	{
		cout << "博客主页底部" << endl;
	}
};
class A3
{
public:
	void head()
	{
		cout << "博客主页头部" << endl;
	}
	void middle()
	{
		cout << "A2的博客内容" << endl;
	}
	void  bottom()
	{
		cout << "博客主页底部" << endl;
	}
};
void test1()
{
	A1 a1;
	A2 a2;
	A3 a3;
	a1.head(); a1.middle(); a1.bottom();
	cout << "=======================" << endl;
	a2.head(); a2.middle(); a2.bottom();
	cout << "=======================" << endl;
	a3.head(); a3.middle(); a3.bottom();
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
每个都封装成类，看到是可以进行正常的输出的，但是，可以发现，重复代码很多，这些是不必要的，那现在就可以试试继承的写法，继承的基本语法为：

  • class 子类 : 继承方式 父类
    {
    子类的特点
    }
  • 子类也可以被叫做派生类
  • 父类也可以被叫做基类

普通用法中，可以将重复的代码，封装到父类当中，将每个子类特别的成员封装在子类里面，那继承方式是什么？

继承方式

继承方式一共有三种：

  1. 公共继承（public）
  2. 保护继承（protected）
  3. 私有继承（private）

在这里插入图片描述

公共继承
  • 父类所有权限不变继承到子类当中，但是不能访问私有权限的成员
保护继承
  • 父类除了私有权限的其他权限都变成保护权限继承到子类当中，私有权限内成员依然不能访问
私有继承
  • 父类中所有权限变成私有权限继承到子类当中，私有权限内成员依然访问不到

那了解了继承方式后，怎么用继承的方式写出上面的网页呢：

#include<iostream>
using namespace std;

class A
{
public:
	void head()
	{
		cout << "博客主页头部" << endl;
	}
	void  bottom()
	{
		cout << "博客主页底部" << endl;
	}
};
class A1:public A
{
public:
	void middle()
	{
		cout << "A1的博客内容" << endl;
	}
};
class A2 :public A
{
public:
	void middle()
	{
		cout << "A2的博客内容" << endl;
	}
};
class A3: public A
{
public:
	void middle()
	{
		cout << "A2的博客内容" << endl;
	}
};
void test1()
{
	A1 a1;
	A2 a2;
	A3 a3;
	a1.head(); a1.middle(); a1.bottom();
	cout << "=======================" << endl;
	a2.head(); a2.middle(); a2.bottom();
	cout << "=======================" << endl;
	a3.head(); a3.middle(); a3.bottom();
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

继承中的对象模型

从父类继承过来的成员，那些属于子类？在继承方式当中提到，私有权限是访问不到的？那是否继承到了子类当中？

#include<iostream>
using namespace std;

class A
{
public:
	int _a;
protected:
	int _b;
private:
	int _c;
};
class A1 :public A
{
public:
	int _d;
};
void test1()
{
	A1 a1;
	cout << sizeof(a1) << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
可以看到，父类内三个int占12，子类一个int占4，加起来正好是16，而输出的结果也是16，说明，父类内所有非静态成员会被继承到子类当中，只是父类内私有权限的成员被编译器藏起来了，不能进行访问，但是确实继承到了子类当中。

继承中的构造和析构顺序

那对于构造和析构呢？是先有的父类还是子类？可以试着用代码进行验证：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout << "父类构造调用" << endl;
	}
	~A()
	{
		cout << "父类析构调用" << endl;
	}
};
class A1:public A
{
public:
	A1()
	{
		cout << "子类构造调用" << endl;
	}
	~A1()
	{
		cout << "子类析构调用" << endl;
	}
};
void test1()
{
	A1 a1;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
可以看到，构造为先有父后由子，析构则反过来。

继承中同名成员访问

非静态成员

当子类和父类中出现了非静态同名成员，如何通过子类对象，访问子类或者父类中的非静态同名成员呢？

  • 子类：直接访问
  • 父类：需要加作用域

这里用代码进行验证：

#include<iostream>
using namespace std;

class A
{
public:
	void a()
	{
		cout << "父类中调用" << endl;
	}
};
class A1:public A
{
public:
	void a()
	{
		cout << "子类中调用" << endl;
	}
};
void test1()
{
	A1 a1;
	a1.a();
	a1.A::a();
}
int main()
{
	test1();
	return 0;
}


成员属性的调用也与函数调用一样，可以用代码来进行验证：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		_a = 10;
	}
	void a()
	{
		cout << "父类中调用" << endl;
	}
	void a(int a)
	{
		cout << "父类第二个函数调用" << endl;
	}
	int _a;
};
class A1:public A
{
public:
	A1()
	{
		_a = 20;
	}
	void a()
	{
		cout << "子类中调用" << endl;
	}
	int _a;
};
void test1()
{
	A1 a1;
	cout << a1._a << endl;
	cout << a1.A::_a << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

那如果在父类中，发生函数重载，子类能直接调用参数不同的那个函数吗？

、#include<iostream>
using namespace std;

class A
{
public:
	void a()
	{
		cout << "父类中调用" << endl;
	}
	void a(int a)
	{
		cout << "父类第二个函数调用" << endl;
	}
};
class A1:public A
{
public:
	void a()
	{
		cout << "子类中调用" << endl;
	}
};
void test1()
{
	A1 a1;
	a1.a(10);
	a1.A::a();
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
编译器直接报错，程序是跑不起来的，这里是因为，在子类中出现与父类同名的成员函数，子类的同名函数会直接隐藏掉父类中所有的同名成员函数。

静态成员

静态成员的访问有两种：

  1. 通过对象访问
  2. 通过类名访问

对于这两个方法，第一种与非静态成员是一样的，可以验证一下第二种——通过类名访问：

#include<iostream>
using namespace std;

class A
{
public:
	static void a()
	{
		cout << "父类中调用" << endl;
	}
};
class A1:public A
{
public:
	static void a()
	{
		cout << "子类中调用" << endl;
	}
};
void test1()
{
	A1 a1;
	A1::a();
	A1::A::a();
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
静态函数发生函数重载时也与非静态函数发生函数重载一样。

多继承

  • 在C++种，允许一个类继承多个类，这个时候就是多继承

语法

  • class 子类: 继承方式 父类1 , 继承方式 父类2 …

注意

  • 在多继承中，多个父类中可能有同名成员出现，这个时候需要加作用域来区分

多继承中的对象模型

那当子类继承多个父类的时候，每个父类内的非静态成员都会被继承过去吗？通过代码验证一下：

#include<iostream>
using namespace std;

class A
{
public:
	int a;
	int b;
};
class A1
{
public:
	int _a;
	int _b;
};
class AA :public A, public A1
{
public:
	int _a1;
	int _b1;
};
void test1()
{
	AA aa;
	cout << sizeof(aa) << endl;
	
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
和普通继承一样，每个父类的非静态成员都会被继承到子类当中。

多继承父类成员名相同

  • 假设现在两个父类，有两个成员名时一样的，那子类能直接访问这个成员吗？
#include<iostream>
using namespace std;

class A
{
public:
	int _a;
	int b;
};
class A1
{
public:
	int _a;
	int _b;
};
class AA :public A, public A1
{
public:
	int _a1;
	int _b1;
};
void test1()
{
	AA aa;
	aa._a;
	
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
编译器是直接报错的，是因为编译器不知道这个成员是来自与哪个父类，这个情况在C++中有个专业名词，叫做二义性，这个时候要怎么样才能访问到呢？就需要进行加作用域，假设现在访问A内的_a:

#include<iostream>
using namespace std;

class A
{
public:
	int _a;
	int b;
};
class A1
{
public:
	int _a;
	int _b;
};
class AA :public A, public A1
{
public:
	int _a1;
	int _b1;
};
void test1()
{
	AA aa;
	aa.A::_a = 10;
	cout<<aa.A::_a<<endl;
	
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

菱形继承

概念

  • 两个子类继承了同一个父类，又有一个类，同时继承了两个子类

在这里插入图片描述

菱形继承出现的问题

  • 马和驴都继承了动物的数据，在骡子使用数据的时候，就会产生二义性，骡子继承动物的数据只需要一份，那应该怎么办？
虚继承

对于上面所说的二义性的问题，因为同样的数据只需要一份，这个时候就可以在继承的时候加上关键字：

  • vritual

将继承变成虚继承，这个时候最大的父类就为虚基类，可以用代码试验：

#include<iostream>
using namespace std;

class A
{
public:
	int a;
	int b;
};
class AA:virtual public A
{


};
class AA1:virtual public A
{

};
class AAA :public AA, public AA1
{

};
void test1()
{
	AAA a;
	a.AA::a = 10;
	a.AA1::a = 20;
	cout << a.AA::a << endl;
	cout << a.AA1::a << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
发现，两个数据修改输出的结果是一样的，这个时候就是虚继承起到的作用，让将内部数据共享了一个，这个时候最小的子类也可以直接访问到这个属性：

#include<iostream>
using namespace std;

class A
{
public:
	int a;
	int b;
};
class AA:virtual public A
{


};
class AA1:virtual public A
{

};
class AAA :public AA, public AA1
{

};
void test1()
{
	AAA a;
	a.AA::a = 10;
	a.AA1::a = 20;
	cout << a.a << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
这是为什么呢？那这个时候从父类继承下来些什么？这个时候从父类继承下来一个指针：

  • vbptr

这个指针叫做虚基类指针，它会指向一个叫做：

  • vbtable

虚基类表，虚基类表中有一个偏移量，这个偏移量会指向一个数据，每个子类指向的数据都是同一份，这个时候数据就只会有一个。
在这里插入图片描述

步入第七层

石碑倒下，大片尘土飞扬，尘土散去，只留下一串脚印，通往第七层…

本章知识点（图片形式）

在这里插入图片描述

😘预知后事如何，关注新专栏，和我一起征服C++这座巨塔
🚀专栏：C++爬塔日记
🙉都看到这里了，留下你们的👍点赞+⭐收藏+📋评论吧🙉

封心锁爱的前夫哥
关注
  • 23
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 17
    评论
专栏目录
面向对象编程—-继承（Python版-案例详解）
01-21
单继承：子类只继承一个父类三.多继承：子类继承多个父类四.子类重写父类的同名属性和方法五.子类调用父类同名属性和方法六.多层继承八.super()的使用 一.继承介绍 现实中的继承 程序中的继承 在程序中，继承描述...
C++进阶：继承
yourfriendyo的博客
04-14 3980
继承 面向对象的三大特性：封装、继承、多态。继承在实际中用的也不是太多，但必须能熟练使用。 1. 继承的概念 继承机制是面向对象思想中复用代码的一种手段，它能够在原有类的特性的基础上进行扩展。由此产生新的类，称为派生类，原有类称作基类。继承体现了面向对象设计的层次结构，体现了由简单到复杂的认知过程，不同于面向过程只有函数复用，继承是类的设计层面上的复用。 1.1 继承的定义 对于具有一定联系的一类群体，将其抽象成一类对象后，这些对象必然会具有重复的属性。 比如学校中有学生老师两种群体，他们都是属于人这个
第十二章：继承
m0_63027727的博客
03-23 1142
第十二章：继承 1.继承的概念及定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 class Person { public: void Print() { cout << "name:" << _name << endl
C++：继承与派生
weixin_51142926的博客
03-11 1185
继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
【C++从入门到入土】第五篇：继承（爆肝画图详解）
qq_52145272的博客
08-26 1556
系列文章目录 【C++从入门到入土】第一篇：从C到C++. 【C++从入门到入土】第二篇：类和对象基础. 【C++从入门到入土】第三篇：类和对象提高. 【C++从入门到入土】第四篇：运算符重载. 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、继承是什么？继承的基本语法继承方式二、继承中的对象模型三、继承中构造和析构顺序四、继承同名成员处理方式五、继承同名静态成员处理方式六、多继承语法总结 前言 接下来让我们一起来学习面向对象三大特性之一——继承，它重要
BaseComponentDemo:封装Base类（一）——利用组件之间的继承关系
05-15
一直带着开发Android的思维，做Android的时候，自己首先会封装base层，把公共的部分抽出来，学RN的时候，就一直在想这个问题，怎么在RN里进行封装，就我目前的了解，有两种解决办法：封装父类高阶组件今天我先讲第一...
Microsoft.Visual.C++.NET技术内幕第六版.part2/2
01-22
总体而言，本书涵盖了当前最新的Visual C++的主流技术，既有对老技术的继承和更新，也有对新技术的精辟阐述。所以，阅读本书可以全面拓宽读者的知识面。从这层意义上讲，本书相当于Visual C++的百科全书，它浓缩了...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 644
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 710
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
【C++】初始化列表
qq_46049113的博客
05-19 129
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
文件操作（C语言）
2303_76654613的博客
05-19 640
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
最新发布
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 611
一篇文章带你学会结构体的内存对齐！！超多精美配图！
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 676
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 940
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
c语言，java语言，python语言之间有什么区别
2301_78349092的博客
05-17 526
c语言是一般计算机类学生上大一的时候学的第一门编程语言，一般来说相对于另外的俩种语言，大学生对于c语言的认识应该是最深刻的。相比较之下来说三者都是被广泛使用的编程语言，它们之间存在显著的区别。总的来说，C语言的优势在于性能和底层能力，Java的优势在于跨平台和安全性，而Python的优势在于易用性和快速开发。根据项目的具体需求和开发团队的技能基础，选择最合适的编程语言至关重要。在对比C语言、Java和Python的优缺点时，我们可以看到它们各自的特点适用于不同的编程需求和应用场景。
【C++】＜知识点＞ 类的大小计算
致力于Linux的博客
05-18 128
C++中使用sizeof计算类大小的内在说明。
C++中使用open和运算符＞＞读取文本文件
qq_41317716的博客
05-16 383
C++中使用open和运算符>>读取文本文件
使用pytorch如何将resnet50第三层和第四层特征融合
05-19
要将resnet50的第三层和第四层特征融合，可以使用PyTorch中的`nn.Module`自定义一个融合模块，具体步骤如下： 1. 首先导入必要的库： ```python import torch import torch.nn as nn ``` 2. 自定义一个融合模块，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

封心锁爱的前夫哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值