C++继承

🕗 发布于 2025-01-20 16:10 c++ 开发语言

1.继承的概念及定义

1.1继承的概念

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

class Person
{
public:
 void Print()
 {
 cout << "name:" << _name << endl;
 cout << "age:" << _age << endl;
 }
protected:
 string _name = "peter"; // 姓名
 int _age = 18;  // 年龄
};
// 继承后父类的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;
}

1.2继承定义

1.2.1定义格式

下面Person是父类，也称作基类，Student是子类，也称派生类
在这里插入图片描述

1.2.2继承关系和访问限定符

在这里插入图片描述

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

在这里插入图片描述
总结：
1.基类private成员在派生类中无论以什么方式继承都是不可见的，这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它
2.基类privte成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected，可以看出保护成员限定符是因继承才出现的
3.实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见，基类的其他成员在子类的访问方式==Min（成员在基类的访问限定符，继承方式），public>protect ed＞private
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式
5.**在实际运用中一般使用都是public继承，几乎很少使用protect ed/private继承，**也不提倡使用protect ed/private继承，因为protect ed/private 继承下来的成员只能在派生类的类里面使用，实际中拓展维护性不强

// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化  
class Person
{
public :
 void Print ()
 {
 cout<<_name <<endl;
 }
protected :
 string _name ; // 姓名
private :
 int _age ; // 年龄
};
//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected :
 int _stunum ; // 学号
};

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

派生类对象可以赋值给基类的对象/基类的指针/基类的引用，这里有个形象的说法叫切片或者切割，寓意把派生类中父类那部分切来赋值过去
基类对象不能赋值给派生类对象
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用，但是必须是基类的指针指向派生类对象时才是安全的，这里的基类如果是多态类型，可以使用RTTI（Run-Time Type Information ）的dynamic cast来进行识别进行安全转换

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;
}

3.继承中都作用域

1.在继承体系中基类和派生类都有独立的作用域
2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义（在子类成员函数中，可以使用基类::基类成员显示访问）
1. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
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 Test()
{
 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 Test()
{
 B b;
 b.fun(10);
};

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

6个默认成员函数，"默认"的意思就是指我们不写，编译器会为我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员，如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用
1. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
3.派生类的operator＝必须要调用基类的operator＝完成基类的复制
4.派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员，因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序
5.派生类对象初始化先调用基类构造再调用派生类构造
6.派生类对象析构清理先调用派生类析构再调用基类的析构
7.因为后续一些场景析构函数需要构成重写，重写的条件之一就是函数名相同，那么编译器会对析构函数名进行特殊处理，处理成destrutor（），所以父类析构函数不加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()
 {
 cout<<"~Student()" <<endl;
 }
protected :
 int _num ; //学号
};
void Test ()
{
 Student s1 ("jack", 18);
 Student s2 (s1);
 Student s3 ("rose", 17);
 s1 = s3 ;
}

5.继承与友元

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

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;
}
void main()
{
 Person p;
 Student s;
 Display(p, s);
}

6.继承与静态成员

基类定义了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;
}

7.复杂的菱形继承及菱形虚拟继承

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

菱形继承:菱形继承是多继承的一种特殊情况

菱形继承问题:从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性问题，在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";
}

虚拟继承可以解决菱形继承的二义性和数据冗余问题，如上面的继承关系，在Student和Teacher 的继承Person时使用虚拟继承，即可解决问题，需要注意的是，虚拟继承不要在其他地方去使用

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";
}

虚拟继承解决数据冗余和二义性的原理
为了研究虚拟继承，给出一个简化的菱形继承体系，借助内存窗口观察对象成员的模型

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对象中将A放到了对象组成的最下面，这里A同时属于B和C，那么B和C如何去找公共的A，这里通过了B和C的两个指针，指向的一张表，这两个指针叫虚基表指针，这两个表叫虚基表，虚基表中存的偏移量，通过偏移量可以找到下面的A
在这里插入图片描述

// 有童鞋会有疑问为什么D中B和C部分要去找属于自己的A？那么大家看看当下面的赋值发生时，d是
不是要去找出B/C成员中的A才能赋值过去？
 D d;
B b = d;
C c = d;

下面是上面的Person关系菱形虚拟继承的原理解释
在这里插入图片描述

8.继承的总结和反思

1.很多人说C++语法复杂，其实多继承就是一个体现，有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，所以一般不建议设计出多继承，一定不要设计菱形继承，否则在复杂度及性能上都有问题
2.多继承可以认为是c++的缺陷之一，很多后来的OO语言都没有继承，如java
3. 继承和组合

public 继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象
组合是一种has-a的关系，假设B组合了A，每个B对象中都有一个A对象
优先使用对象组合，而不是类继承。
继承允许根据基类的实现来定义派生类的实现，这种通过生成派生类的复用通常被称为白箱复用（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; // 轮胎
   };

9.题

1.什么是菱形继承，菱形继承的问题是什么
概念：在C++等编程语言中，菱形继承是一种多继承的特殊情况。当一个类有两个基类，而这两个基类又共同继承自一个基类时，就形成了菱形继承结构。

菱形继承的问题：

数据冗余
二义性

2.什么是菱形虚拟继承，如何解决数据冗余和二义性的
概念：菱形虚拟继承是在菱形继承的基础上，使用虚拟继承来解决数据冗余和二义性问题。在上述例子中，如果将类B和类C对类A的继承改为虚拟继承，就形成了菱形虚拟继承。

如何解决数据冗余和二义性

解决数据冗余
解决二义性

3.继承和组合的区别，什么时候用继承，什么时候用组合
区别：

概念本质：
继承：是一种“is - a”关系，表示派生类是基类的一种特殊类型。例如，“汽车”类可以继承自“交通工具”类，因为汽车“is - a”交通工具。
组合：是一种“has - a”关系，表示一个类包含另一个类的对象。例如，“汽车”类可以包含一个“发动机”类的对象，因为汽车“has - a”发动机。
代码实现和结构：
继承：通过继承语法（如C++中的class Derived : public Base），派生类可以直接继承基类的成员变量和成员函数。派生类可以重写基类的虚函数来实现多态等功能。
组合：在类的定义中包含其他类的对象作为成员变量。
耦合性：
继承：继承具有较高的耦合性。因为派生类紧密依赖于基类的实现细节，如果基类发生改变，可能会影响到派生类。例如，如果在基类中修改了一个非虚函数的实现，派生类可能会受到意外的影响。
组合：组合的耦合性相对较低。一个类只使用其他类的对象，而不依赖于其他类的内部实现细节。如果被包含的类发生改变，只要其接口不变，包含它的类通常不需要做太多修改。

使用场景
何时使用继承
当存在明确的“is - a”关系时适合使用继承。例如，“正方形”是一种特殊的“矩形”，可以让“正方形”类继承自“矩形”类。在图形绘制系统中，如果有一个基类“图形”，各种具体的图形如“圆形”、“三角形”等可以继承自这个基类，以便共享一些通用的属性和操作，如计算面积、绘制轮廓等。
何时使用组合
当存在“has - a”关系时适合使用组合。例如，在一个“订单”类中，可能包含“顾客”类的对象、“商品列表”类的对象等，因为订单“has - a”顾客和商品列表。在一个“计算机”类中，可以包含“CPU”、“内存”、“硬盘”等类的对象，因为计算机“has - a”这些组件。

原文地址：https://blog.csdn.net/weixin_65793499/article/details/144570090

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：一文大白话讲清楚webpack基本使用——2——css相关loader的配置和使用
下一篇：MFC程序设计（一）MFC入门

react中，使用antd的Upload组件切片上传.zip文件及压缩包的下载
【代码】react中，使用antd的Upload组件切片上传.zip文件及压缩包的下载。
阅读更多2025-01-21
Spring Boot 启动流程解析及重点源码
综上所述，我们详细解析了 Spring Boot 应用程序的启动流程，并提供了关键步骤中的源码分析。了解这一过程不仅有助于我们更好地掌握 Spring Boot 的工作原理。
阅读更多2025-01-21
在Spring Boot中使用SeeEmitter类实现EventStream流式编程将实时事件推送至客户端
是浏览器与服务器之间的一种通信机制，允许服务器向客户端发送事件流。与WebSocket不同，SSE是单向通信，适用于需要实时更新数据的场景，如通知、新闻推送、实时数据更新等。SSE的工作方式是：客户端
阅读更多2025-01-21
深入Spring Boot：自定义Starter开发与实践
Starter是SpringBoot的核心组件之一，它是一种依赖管理机制，旨在简化Spring应用的开发过程。通过引入一个Starter模块，开发者可以快速启用SpringBoot提供的特定功能，而无
阅读更多2025-01-21
低代码系统-产品架构案例介绍（三）
简单介绍一个低代码产品。
阅读更多2025-01-21
Dify：低代码 AI 应用开发平台详解与实战指南
Dify是一个低代码AI应用开发框架，支持多种大语言模型（LLM），允许用户通过可视化界面或API轻松创建AI应用，无需深厚的编程技能。
阅读更多2025-01-21
Ae 表达式语言引用：Layer - 3D
Layer-3D（3D 图层属性）组允许访问和控制图层的三维变换属性、光照属性、材质属性、反射属性等。通过这些属性，可以实现动态的三维旋转、光照效果控制、材质特性调整，极大地提升 After Effe
阅读更多2025-01-21
畅游Diffusion数字人(14)：基于3D人体网格的语音驱动手势视频生成 ECCV 2024
根据语音输入生成与说话内容、情感和节奏相匹配的自然、流畅且逼真的手势视频。该技术在虚拟形象、虚拟现实、动画制作等领域具有重要应用价值。然而这方面的研究非常少，这篇博客解读一篇ECCV2024的最新论文
阅读更多2025-01-21
Zemax STAR 模块的入门设置
下一步是通过使用下拉手册将表面分配给数据集，将每个多物理场数据与相应的表面对齐。Zemax OpticStudio 中的 STAR 模块允许直接导入来自有限元分析（FEA）软件的变形数据，从而将光
阅读更多2025-01-21
拓扑学：单纯形(simplex)
拓扑学：单纯形(simplex)
阅读更多2025-01-21