C++ 第九章 继承与派生

最新推荐文章于 2024-09-16 17:46:36 发布
最新推荐文章于 2024-09-16 17:46:36 发布
阅读量1k 收藏 21
点赞数 23
文章标签： c++ 开发语言 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74774974/article/details/135324287
版权

在这里插入图片描述

继承(Inherit) 是一种联结类的层次模型，允许和鼓励类的重用用以扩展已存在的功能，提供了一种明确表述共性的方法，实现代码重用。继承是面向对象程序设计的重要特征。
派生(derive) 是继承的产物，派生是通过继承基类中原有的特性，并在此基础上修改原有功能或添加一些新的功能来产生新类。现实世界中利用分类、分层次进行分析和描述事物特征的事例很多，如交通工具、动物类等等。

9.2 继承与派生的概念

在这里插入图片描述
在定义一个新类时，使用了已存在类中部分或全部特性，称继承。定义的新类称派生类（或子类），已存在的类称基类（或父类）。从一个类出发产生新类的过程称派生。派生类也可以作为基类再派生其子类，形成类的层次结构，构成一个类族。通过类的继承与派生关系，建立具有共同特征的类族，从而实现了代码重用。
在继承与派生过程中，如果一个派生类是由一个基类派生，称单一继承；由两个或以上基类共同派生称多重继承。

在继承与派生时，必须同时满足两个条件：需要从基类中继承部分或全部属性和行为特性，并在此基础上有约束或扩展。即：
（1）继承基类中部分或全部数据成员和函数成员；
（2）改变基类中部分成员数据成员和函数成员；
（3）增加新的数据成员和函数成员。

9.2.2 派生类的定义

通过基类派生子类的一般格式为：

class <派生类名>：<继承方式><基类名1>，……
{	派生类成员说明}；

继承方式有三种，分别通过关键字public（公有继承）、**private（私有继承）和protected（保护继承）**说明。不同继承方式，将决定派生类如何访问从基类中继承来的不同访问权限的成员。在没有说明继承方式时，默认为private。

【例9.1】定义描述二维平面中一个点的类，并以此为基类派生出平面上圆的类。

class point//描述二维平面中一个点的类 
	double x,y;
	public:
		point(float i,float j){
			x=i;y=j;
		}
		double area(){
			return 0.0
		}
};
class circle:public point// 在基类point成员基础上增加半径成员，派生了圆类
{
	double radius;
	public:
		circle(double r=0){
			radius=r;
		} 
		double area(){
			return PI*radius*radius;
		} ;
 };

9.2.3 基类成员的访问控制

继承与派生时，派生类继承了基类中除构造、析构函数外的所有成员，这些成员在派生类内或派生类外的访问权限，由继承方式决定。

1. 公有继承

公有继承时，基类中具有公有和保护访问权限的成员在派生类中保持不变，即作为派生类的公有和保护访问权限的成员，基类中私有访问权限的成员在派生类中不可直接访问，但可以通过基类中公有函数成员访问基类中的私有成员。

【例9.2】说明一个矩形类，通过公有继承方式，派生长方体类，通过派生类成员函数和派生类的对象访问基类中不同访问权限的成员。

#include<iostream>
using namespace std;
class Rectangle
{
	float length;
	protected:
		float width;
	public:
		Rectangle(){
			length=0;width=0;
		} 
		Rectangle(float l,float w){
			length=l;width=w;
		}
		float Area(){
			return length*width;
		}
		float GetL(){
			return length;
		}
		float GetW(){
			return width;
		}
		void RPrint(){
			cout<<"矩形的长为："<<length;
			cout<<"\t宽为"<<width;
		}
};
class Cuboid:public Rectangle
{
	float high;
	public:
		Cuboid(){
			high=0;
		}
		Cuboid(float l,float w,float h):Rectangle(l,w){
			high=h;
		} 
		void CPrint()
		{
			cout<<"长方体的长为:"<<GetL()<<"\t宽为:"<<width;
			cout<<"\t高为："<<high<<"\t体积为:"<<high*Area()<<'\n';
		}
};
int main(){
	Rectangle r(10,5);
	r.RPrint();
	cout<<"\t面积为:"<<r.Area()<<'\n';
	Cuboid c(6,3,10);
	cout<<"矩形的长为："<<c.GetL()<<"\t宽为："<<c.GetW();
	cout<<"\t面积为:"<<c.Area()<<'\n';
	c.CPrint(); 
}

在这里插入图片描述
在这里插入图片描述

2. 私有继承

私有继承时，基类中具有公有和保护访问权限的成员成为派生类的私有成员，基类中私有访问权限的成员在派生类中不可直接访问，在派生类内可以通过基类中公有函数成员访问基类中的私有成员。

【例9.3】说明一个矩形类，通过私有继承方式，派生一个长方体类，通过派生类成员函数和派生类的对象访问基类中不同访问权限的成员。

#include<iostream>
using namespace std;
class Rectangle
{
	float length;
	protected:
		float width;
	public:
		Rectangle(){
			length=0;width=0;
		} 
		Rectangle(float l,float w){
			length=l;width=w;
		}
		float Area(){
			return length*width;
		}
		float GetL(){
			return length;
		}
		float GetW(){
			return width;
		}
		void RPrint(){
			cout<<"矩形的长为："<<length;
			cout<<"\t宽为"<<width;
		}
};
class Cuboid:private Rectangle
{
	float high;
	public:
		Cuboid(){
			high=0;
		}
		Cuboid(float l,float w,float h):Rectangle(l,w){
			high=h;
		} 
		void CPrint()
		{
			cout<<"长方体的长为:"<<GetL()<<"\t宽为:"<<width;
			cout<<"\t高为："<<high<<"\t体积为:"<<high*Area()<<'\n';
		}
};
int main(){
	Rectangle r(10,5);
	r.RPrint();
	cout<<"\t面积为:"<<r.Area()<<'\n';
	Cuboid c(6,3,10);
	c.CPrint(); 
}

在这里插入图片描述

3. 保护继承

保护继承时，基类中具有公有和保护访问权限的成员成为派生类的保护成员，基类中私有访问权限的成员在派生类中不可直接访问。保护继承很少使用。

4. 各种继承方式对不同访问权限基类成员的访问控制

在这里插入图片描述

9.3 派生类的构造与析构函数

继承与派生是在继承基类成员的基础上，添加了新的成员。但在继承与派生过程中，基类的构造函数和析构函数是不能被继承的。因此在派生类中，一方面要负责为新增的成员进行初始化工作，另一方面还需要为从基类中继承来的成员进行初始化工作。
派生类为新增的成员进行初始化工作，需要在派生类中定义构造函数实现，而对从基类中继承来的成员进行初始化工作，还是由基类中的构造函数完成。

1. 构造函数

   派生类的构造函数定义的一般格式为：
派生类名::派生类名(<形参表>):基类名1(<实参表>)，……
{
	派生类新增成员数据的初始化
}
  注：如果基类没有说明构造函数，则派生类中也可以不定义构造函数，定义派生类对象时，将全部调用缺省的构造函数。

当说明派生类对象时，系统首先调用各基类的构造函数，对基类成员进行初始化，之后执行派生类的构造函数。具体调用执行顺序是：
首先，调用基类的构造函数。多重继承时，其调用顺序按照定义派生类时，对基类的说明顺序确定。
其次，执行派生类的构造函数的函数体。

2. 拷贝构造函数

 派生类拷贝构造函数定义的一般格式为：
派生类名::派生类名(派生类名 &obj):基类名1(obj)，……
{
	完成派生类新增成员数据的拷贝
}
   其中：派生类中定义拷贝构造函数的参数是派生类对象的引用。

3. 析构函数

继承与派生时，析构函数也不能继承，如果需要，则应在派生类中重新定义析构函数。派生类的析构函数与没有继承与派生的析构函数定义方法相同。

【例9.4】在继承与派生过程中，构造函数和析构函数的定义及调用关系。

#include<iostream>
using namespace std;
class BASE1
{
	int x;
	public:
		BASE1(int a=0)
		{
			x=a;
			cout<<"调用基类BASE1的构造函数！\n";
		}
		~BASE1()
		{
			cout<<"调用基类BASE1的析构函数！\n";
		 }
};
class BASE2
{
	int y;
	public:
		BASE2(int a=0)
		{
			y=a;
			cout<<"调用基类BASE2的构造函数！\n";
		}
		~BASE2()
		{
			cout<<"调用基类BASE2的析构函数！\n"; 
		}
};
class DERIVE:public BASE1,public BASE2
{
	int z;
	public:
		DERIVE(int a,int b, int c):BASE1(a),BASE2(b)
		{
			z=c;
			cout<<"调用派生类DERIVE的构造函数!\n";
		 } 
		~DERIVE()
		{
			cout<<"调用派生类DERIVE的析构函数!\n";
		}
};
int main(){
	DERIVE d(10,20,30);
}

在这里插入图片描述

 当派生类中还包含对象成员时，派生类构造函数定义的一般格式为：
派生类名::派生类名(<形参表>):基类名1(<实参表>)，……，对象成员(<实参表>)，……
{	派生类新增成员数据的初始化}
其中：<形参表>既要满足对派生类新增成员数据的需要，同时也要包含对基类中成员数据和对象成员初始化的需要。

9.4 冲突、支配与赋值兼容规则

1. 冲突

在多重继承时，如果多个基类中具有相同名字的成员，且在基类中的访问权限为公有(public)或保护(protected)，当派生类使用到该基类中的成员时，将会出现不唯一性，称为冲突。

【例9.6】多重继承时引起冲突的例子。

#include<iostream>
using namespace std;
class BASE1
{
	public:
		int x;
		BASE1(int a=0)
		{
			x=a;}
			void Print(){
				cout<<"x="<<x<<'\n';
			};
};
class BASE2
{
protected:
	int x;
	public:
		BASE2(int a=0)
		{x=a;}
		void Print(){
			cout<<"x="<<x<<'\n';
		}
};
class DERIVE:public BASE1,public BASE2
{
	int z;
	public:
		DERIVE(int a,int b, int c):BASE1(a),BASE2(b)
		{z=c;}
			int Area(){
				return x*x; }//A
			void PrintC(){
				cout<<"z="<<z<<'\n';
			}
};
int main(){
	DERIVE d(10,20,50);
	d.Print();//B
}

解决冲突问题有如下两种方法：
限定基类中的访问权限为私有成员
使用作用域运算符区分基类成员
使用作用域运算符区分基类成员，是在使用基类成员时，成员名前加类名和作用域运算符，以说明属哪个基类。其格式为：
<类名>：：<成员名>

#include<iostream>
using namespace std;
class BASE1
{
	public:
		int x;
		BASE1(int a=0)
		{
			x=a;}
			void Print(){
				cout<<"x="<<x<<'\n';
			};
};
class BASE2
{
protected:
	int x;
	public:
		BASE2(int a=0)
		{x=a;}
		void Print(){
			cout<<"x="<<x<<'\n';
		}
};
class DERIVE:public BASE1,public BASE2
{
	int z;
	public:
		DERIVE(int a,int b, int c):BASE1(a),BASE2(b)
		{z=c;}
			int Area(){
				return BASE1::x*BASE2::x; }//A
			void PrintC(){
				cout<<"z="<<z<<'\n';
			}
};
int main(){
	DERIVE d(10,20,50);
	d.BASE1::Print();//B
	d.PrintC();
}

在这里插入图片描述

2. 支配规则

在多在继承与派生时，如果基类中，访问权限为public或protected成员，和派生类添加的新成员同名时，则不会引起冲突，**派生类的成员将覆盖基类中的同名成员**。**这种优先关系称为支配规则**。支配规则强调了**派生类中成员优先的原则**，如果需要使用基类中的成员，须使用作用域运算符，强调说明属于基类的成员。

【例9.8】继承与派生时，支配规则的使用。

#include<iostream>
using namespace std;
class BASE
{
	public:
		int x;
		BASE(int a=0)
		{
			x=a;}
			void Print(){
				cout<<"BASE x="<<x<<'\n';
			};
};
class DERIVE:public BASE
{
	int x;
	public:
		DERIVE(int a,int b):BASE(a){
			x=b;
		}
			int Area(){
				return x*BASE::x;}//A
			void PrintC(){
				cout<<"DERIVE x="<<x<<'\n';
			}
};
int main(){
	DERIVE d(10,20);
	d.BASE::Print();//B
	d.PrintC();//C
}

在这里插入图片描述

3. 赋值兼容规则

在面向对象程序设计中，相同类型对象间可以相互赋值，但在基类与派生类对象间实现赋值存在赋值兼容关系。**由于派生类中包含从基类继承的成员，因此可以将派生类对象的值赋给基类对象，称为赋值兼容规则**。

具体规则包括以下几点：
（1）派生类的对象可以赋给基类的对象，将派生类对象中从基类继承来的成员赋给基类的对象。
（2）可以将派生类对象的地址赋给指向基类对象的指针。
（3）派生类对象可以初始化基类的引用。

9.5 虚基类

如果一个派生类由多个基类共同派生，并且这些基类又具有共同的基类，则在最终产生的派生类中，会保留该共同基类数据成员的多份同名成员，在引用这些同名成员时可能会产生二义性（冲突）。如基类A分别派生了类B和类C，类B和类C共同派生类D 。
在这里插入图片描述
【例9.9】共同基类在最终的派生类中出现多份同名成员。

#include<iostream>
using namespace std;
class BASE
{
public:
     int x;
     BASE(int a){x=a;}
     void Print()
     {   cout<<"BASE x="<<x<<'\n';}
};
class BASE1:public BASE
{public:	int y;
     BASE1(int a,int b):BASE(a){y=b;}
     void Print1()
     {	  cout<<"BASE1 x="<<x<<'\n';
	  cout<<"BASE1 y="<<y<<'\n';	
     }
};
class BASE2:public BASE
{public:	int z;
     BASE2(int a,int b):BASE(a)	{z=b;}
     void Print2()
     {	  cout<<"BASE2 x="<<x<<'\n';
	  cout<<"BASE2 z="<<z<<'\n';	
     }
};
class DERIVE:public BASE1,public BASE2
{	int sum;
public:
	DERIVE(int a,int b,int c,int d)
           :BASE1(a,b),BASE2(c,d)
	{  sum=a+b+c+d;}
	void PrintD()
	{
	    //Print();		//A
	    Print1();		//B
	    Print2();		//C
	cout<<"DERIVE sum="<<sum<<'\n';
	}
};
int main()
{
	DERIVE d(10,20,100,200);
	d.PrintD();
}

在这里插入图片描述
从上述结果中可以看到，派生类DERIVE中，分别从派生类BASE1和派生类BASE2各继承一份共同基类BASE中的x成员，并且他们自己各自有独立数据。为使得在间接继承共同基类时，派生类中只保留一份共同基类的成员，C++提供虚基类的方法。

声明虚基类的一般格式为：
class <派生类名>：virtual <继承方式><基类名>
{…..};
其中：关键字virtual可以放在<继承方式>的前面，也可以放在后面，其作用一样。

与一般基类的初始化过程相似，虚基类的初始化同样由构造函数实现。所不同的是，由虚基类经过一次或多次派生出来的派生类，在其每一个派生类的构造函数的成员初始化列表中，必须给出对虚基类的构造函数的调用，如果未列出，则调用虚基类的缺省构造函数。C++编译器约定，在执行直接派生类的构造函数时不调用虚基类的构造函数，而是在最终派生类的构造函数中直接调用虚基类的构造函数。

【例9.9】共同基类在最终的派生类中出现多份同名成员。

#include<iostream>
using namespace std;
class BASE
{
public:
     int x;
     BASE(int a){x=a;}
     void Print()
     {  cout<<"BASE x="<<x<<'\n';}
};
class BASE1:virtual public BASE
{public:	int y;
     BASE1(int a,int b):BASE(a){y=b;}
     void Print1()
     {	  cout<<"BASE1 x="<<x<<'\n';
	  cout<<"BASE1 y="<<y<<'\n';	
     }
};
class BASE2:public virtual BASE
{public:	int z;
     BASE2(int a,int b):BASE(a){z=b;}
     void Print2()
     {	  cout<<"BASE2 x="<<x<<'\n';
	  cout<<"BASE2 z="<<z<<'\n';	
     }
};
class DERIVE:public BASE1,public BASE2
{	int sum;
public:
	DERIVE(int a,int b,int c,int d)
      :BASE1(a,b),BASE2(c,d),BASE(a+c)
	{sum=a+b+c+d;}
	void PrintD()
	{
		Print();		//A
		Print1();		//B
		Print2();		//C
	cout<<"DERIVE sum="<<sum<<'\n';
	}
};
int main()
{
	DERIVE d(10,20,100,200);
	d.PrintD();
}

在这里插入图片描述

暗托涅瓦
关注
c++继承
iKan的博客
04-15 275
可以继承到，不一定访问到 继承时的声明为准，从左向右 基类，内嵌，派生类 #include <iostream> using namespace std; class Base1 { public : Base1(int i) { cout << "Constructing Basel" << i << endl; } }; cl...
十六. C++继承与派生
ouyangyiwen的博客
12-29 100
为什么需要继承？ 继承：减少代码重复内容。C++通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。 一个B类继承于A类，或称从A类派生类B。这样的话，类A成为基类，类B成为派生类。 派生类的成员，包含两大部分： 一类是从基类继承过来的，一类是自己增加的成员 从基类继承过来的表现其共性，而新增的成员体现了其个性 派生类继承方式： #define _CRI_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_
【C++笔记】C++继承与派生中的构造函数
学仙只为看看天的专栏
05-23 2877
C++中，构造函数与父类的其它成员(成员变量和成员方法)不同，它不能被子类继承。因此，在创建子类对象时，为了初始化从父类中继承来的成员变量，编译器需要调用其父类的构造函数。 关于子类中构造函数的构造原则，可分为以下4种情况分别来看： 1. 父类没有声明构造函数 (1) 子类也没有声明自己的构造函数，则父类和子类均由编译器生成默认的构造函数。 (2) 子类中声明了构造函数(无参或者带参)，则子类的构造函数可以写成任何形式，不用顾忌父类的构造函数。在创建子类对象时，先调用父类默认的构造函数(编译...
C++ 派生类的拷贝构造函数
NuYoaH502329的博客
08-06 487
当存在类的继承关系时，对于一个类，如果程序员没有编写拷贝构造函数，编译系统会在必要时自动生成一个隐含的拷贝构造函数，这个隐含的拷贝构造函数会自动调用基类的拷贝构造函数，然后对派生类新增的成员对象一一执行拷贝。如果要为派生类编写拷贝构造函数，一般需要为基类相应的拷贝构造函数传递参数。由于类型兼容规则的作用，可以用派生类的对象去初始化基类的引用，所以上面B类的拷贝构造函数的参数是D类对象的引用dd。
定义派生类拷贝构造函数
weixin_34040079的博客
09-27 934
2019独角兽企业重金招聘Python工程师标准>>> ...
派生类的拷贝构造函数
weixin_33973600的博客
08-23 822
刚刚弄了一个关于派生类的实验，里面涉及到了派生类的拷贝构造函数，这时才发现自己在这个知识点上还很模糊。在CSDN上面看了下相关的一篇文章后，稍微有了点感觉。现总以一个例子总结如下： 情况(1). 派生类的copy constructor未定义 #include <iostream> using namespace std ; ...
C++基础（8）继承和派生
qq_43685242的博客
07-07 221
1. 继承 1.1 继承概述 继承的意义： c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。 一个B类继承于A类，或称从类A派生类B。这样的话，类A成为基类（父类）， 类B成为派生类（子类）。 派生类中的成员，包含两大部分： 一类是从基类继承过来的，一类是自己增加的成员。 从基类继承过过来的表现其共性，而新增的成员体现了其个性。 1.2 派生类定义 派生类的代码格式： Class 派生类名 : 继承方式 基类名{
C++程序设计：第9章++继承与派生.ppt
09-19
【C++程序设计：第9章 继承与派生】 继承与派生是C++中面向对象编程的重要概念，它们允许我们构建类的层次结构，有效地实现代码重用和扩展。继承允许一个类（派生类）从另一个类（基类）中获取属性和行为，从而减少...
c++课件第九章继承共29页.pdf.zip
10-29
本课件“C++课件第九章继承共29页”深入探讨了这一主题，旨在帮助学习者掌握这一强大的工具。以下是关于C++继承的详尽解析： 1. 继承的概念： 继承是OOP（面向对象编程）的关键特性，它允许一个类（子类或派生类）...
【C++面向对象程序设计】CH5 继承与派生
m0_72318954的博客
11-28 1455
继承与派生介绍
C++程序设计：第八章 继承与多态.pdf
09-19
通过上述示例和分析，我们可以看到继承与派生在C++程序设计中的应用，如何通过继承方式来控制访问权限，以及如何在派生类中访问基类的成员变量和成员函数。掌握这些概念对于深入理解面向对象编程是至关重要的。
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1120
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 285
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 542
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 855
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 589
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 436
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
CCF201903_1
m0_67663419的博客
09-14 218
【代码】CCF201903_1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值