【C++】继承相关知识详细梳理

2024-09-01 17:12

本文主要是介绍【C++】继承相关知识详细梳理,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

1.继承简介

        什么是继承

        继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段它允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称派生类

        继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程,继承是类设计层次的复用。

        举例说明:

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;
}
protected:string _name = "peter"; // 姓名int _age = 18; // 年龄
};
ps:父类 --- 被继承的类 (这里是Person)子类 --- 继承父类的类 (这里是Student和Teacher)
// 继承后父类的Person的成员(成员函数+成员变量)都会变成子类的一部分。这里体现出了
Student和Teacher复用了Person的成员。如果使用监视窗口查看Student和Teacher对象,可
以看到变量的复用。调用Print可以看到成员函数的复用。
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;
}

2.继承的使用方法 

        2.1定义格式

        还是以上面的例子为例:

 2.2继承方式与访问限定符

        继承方式和访问限定符有:

 

两者使用的关键字相同,但使用的位置不同,继承方式和访问限定符息息相关,其关系如下:

要点: 

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。但是即便如此,基类的私
有成员还是被继承到了派生类对象中
只是语法上限制了派生类对象不管在类里面还是类外面
都不能去访问它。


2. 基类private成员在派生类中不能被访问,但如果基类成员不想在类外直接被访问,又想要在
派生类中能访问,就可以定义为protected。
如果没有继承,protected和private是没什么区别的。


3. 基类的私有成员在子类都是不可见。

        基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符,继承方式),

        public > protected> private。


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


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

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

        概念:

        派生类对象可以赋值给 基类的对象 / 基类的指针 / 基类的引用。形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。(注意别弄反了)

        基类对象不能直接赋值给派生类对象。

        基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
的指针是指向派生类对象时才是安全的。这里基类如果是多态类型,可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。(关键词RTTI,可以先了解)

        

 例子:

class Person
{
protected:string _name; // 姓名string _sex; // 性别int _age; // 年龄
};
class Student : public Person
{
public:int _No; // 学号
};void Test()
{Student sobj;// 1.子类对象可以赋值给父类对象/指针/引用Person pobj = sobj;Person* pp = &sobj;//指针传给指针Person& rp = sobj;//2.基类对象不能赋值给派生类对象//sobj = pobj;// 3.基类的指针可以通过强制类型转换赋值给派生类的指针pp = &sobj;Student * ps1 = (Student*)pp; // 这种情况转换时可以// 因为父类本来就指向子类的父类部分,子类的指针访问不会越界ps1->_No = 10;pp = &pobj;Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以,但是会存在越界访问的问题ps2->_No = 10;
}

4.继承中的作用域(隐藏的概念)

        1. 在继承体系中基类和派生类都有独立的作用域。


        2. 子类和父类中有同名成员,在子类中 子类成员将屏蔽对父类同名成员的直接访问,

        这种情况叫隐藏,也叫重定义。(在子类成员函数中,可以使用 基类::基类成员 显示访问)


        3. 需要注意的是如果是成员函数的隐藏,只需要函数名相同就构成隐藏


        4. 注意在实际中在继承体系里面最好不要定义同名的成员。

举例:

// Student的_num和Person的_num构成隐藏关系,可以看出这样代码虽然能跑,但是非常容易混淆
class Person
{
protected:string _name = "小李子"; // 姓名int _num = 111; // 身份证号
};
class Student : public Person
{
public:void Print(){cout << " 姓名:" << _name << endl;cout << " 身份证号:" << Person::_num << endl;cout << " 学号:" << _num << endl;}
protected:int _num = 999; // 学号
};
void Test1()
{Student s1;s1.Print();
};
// B中的fun和A中的fun不是构成重载,因为不是在同一作用域
// B中的fun和A中的fun构成隐藏,成员函数满足函数名相同就构成隐藏。
class A
{
public:void fun(){cout << "func()" << endl;}
};class B : public A
{
public:void fun(int i){A::fun();cout << "func(int i)->" << i << endl;}
};void Test2()
{B b;b.fun(10);//b.fun();// 如果这样写就会报错,因为B中的fun函数对A中的fun构成隐藏,// 无法访问到A中的无参fun(),只能访问到b中的fun(int i)//error:“B::fun”: 函数不接受 0 个参数
};int main()
{Test1();Test2();
}

5.派生类的默认成员函数 

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


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


3. 赋值运算符重载:派生类的operator=必须要调用基类的operator=完成基类的复制。


4. 析构函数:派生类的析构函数调用后自动调用基类的析构函数清理基类成员,无需显示调用基类析构函数。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

调用顺序:
        派生类对象初始化先调用基类构造再调派生类构造。


        派生类对象析构清理先调用派生类析构再调基类的析构。(与构造顺序相反)


     (虚函数/重写部分内容)因为后续一些场景析构函数需要构成重写,重写的条件之一是函数名相同,那么编译器会对析构函数名进行特殊处理,处理成destructor(),所以父类析构函数不加virtual的情况下,子类析构函数和父类析构函数构成隐藏关系。

例如:

class Person
{
public:Person(const char* 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;}
protected:string _name; // 姓名
};
class Student : public Person
{
public:Student(const char* name, int num): Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s): Person(s)//赋值转换,调用拷贝构造, _num(s._num){cout << "Student(const Student& s)" << endl;}Student& operator = (const Student& s){cout << "Student& operator= (const Student& s)" << endl;if (this != &s){Person::operator =(s);_num = s._num;}return *this;}~Student(){//Person::~Person();显示调用会出错,因为析构顺序有问题,虽然不会报错cout << "~Student()" << endl;}
protected:int _num; //学号
};
void Test()
{Student s1("jack", 18);Student s2(s1);Student s3("rose", 17);s1 = s3;
}int main()
{Test();return 0;
}

可以对比分析基类和派生类成员函数的调用顺序。

 6.继承和友元

        友元关系并不能继承,也就是说基类的友元无法访问派生类私有和保护成员。

例子:

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;//error C2248: //“Student::_stuNum”: 无法访问 protected 成员(在“Student”类中声明)
}
void main()
{Person p;Student s;Display(p, s);
}

7.继承和静态成员

        基类定义了static静态成员,则整个继承体系里面只有一个这样的成员。和静态成员本来的定义相似,无论派生出多少个子类,都只有一个static成员实例 。(虽然只有一个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; // 研究科目
};
void TestPerson()
{Student s1;Student s2;Student s3;Graduate s4;cout << " 人数 :" << Person::_count << endl;Student::_count = 0;cout << " 人数 :" << Person::_count << endl;
}int main()
{TestPerson();return 0;
}

8.菱形继承和菱形虚拟继承 

        继承关系分为以下几种:

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

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

3. 菱形继承:菱形继承是多继承的一种特殊情况。(存在数据冗余和二义性的情况)

 

 菱形继承的问题:可以看出菱形继承有数据冗余和二义性的问题。

                               (在Assistant的对象中Person成员会有两份)

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 ; // 主修课程
};
void Test ()
{// 这样会有二义性无法明确知道访问的是哪一个Assistant a ;a._name = "peter";// 需要显示指定访问哪个父类的成员可以解决二义性问题,但是数据冗余问题无法解决a.Student::_name = "xxx";a.Teacher::_name = "yyy";
}int main()
{Test();return 0;
}

 为了解决菱形继承的问题,有了虚拟继承的概念。

        虚拟继承可以解决菱形继承的二义性和数据冗余的问题。

其使用非常简单,只需加上关键字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 ; // 主修课程
};
void Test ()
{Assistant a ;a._name = "peter";//此时不存在数据冗余和二义性的问题了
}

注意:在产生数据冗余的地方,例如Teacher和Student部分使用虚拟继承,其他地方不要使用。

8.1菱形虚拟继承的原理

        举例说明:

class A
{
public:int _a;
};
//class B : public A
class B : virtual public A
{
public:int _b;
};
// class C : public A
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中分布存放了B和C的完整结构,最下面是自己的成员,B和C分布都是一部分是基类A的成员,一部分是自己的成员。

        再看使用菱形虚拟继承时内存的分布情况:

那么B和C是如何找到A的呢?

        这里是通过了B和C的两个指针,指向的一张表(可以在上图中找到B,C共有的那个变量)。这两个指针叫虚基表指针,这两个表叫虚基表。虚基表中存着B和C相对于A的偏移量。他们通过偏移量可以找到下面的A。
         可以用下面的图概括:
 

9.继承补充

        1. 有了多继承,就存在菱形继承,有了菱形继承就有菱形虚拟继承,底层实现就很复杂。所以一般不建议设计出多继承,一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
        2. 多继承可以认为是C++的缺陷之一,很多后来的语言都没有多继承,如Java。
        3.用继承还是用组合:

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

        4.优先使用对象组合,而不是类继承 。

        继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言:在继承方式中,基类的内部细节对子类可见 。继承一定程度破坏了基类的封装,基类的改变,对派生类有很大的影响。派生类和基类间的依赖关系很强,耦合度高。

        对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse),因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系,耦合度低。优先使用对象组合有助于你保持每个类被封装。实际尽量多去用组合。组合的耦合度低,代码维护性好。不过继承也有用武之地的,有些关系就适合继承那就用继承,另外要实现多态,也必须要继承。

// Car和BMW Car和Benz构成is-a的关系
class Car{
protected:string _colour = "白色"; // 颜色string _num = "陕ABIT00"; // 车牌号
};
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; // 轮胎
};

这篇关于【C++】继承相关知识详细梳理的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1127549

相关文章

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

sqlite3 相关知识

WAL 模式 VS 回滚模式 特性WAL 模式回滚模式(Rollback Journal)定义使用写前日志来记录变更。使用回滚日志来记录事务的所有修改。特点更高的并发性和性能;支持多读者和单写者。支持安全的事务回滚,但并发性较低。性能写入性能更好,尤其是读多写少的场景。写操作会造成较大的性能开销,尤其是在事务开始时。写入流程数据首先写入 WAL 文件,然后才从 WAL 刷新到主数据库。数据在开始

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

系统架构师考试学习笔记第三篇——架构设计高级知识(20)通信系统架构设计理论与实践

本章知识考点:         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识

【C++高阶】C++类型转换全攻略:深入理解并高效应用

📝个人主页🌹:Eternity._ ⏩收录专栏⏪:C++ “ 登神长阶 ” 🤡往期回顾🤡:C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝