继承初识/虚拟继承原理刨析

于 2024-09-20 21:43:39 发布
阅读量707 收藏 14
点赞数 21
文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73920434/article/details/142335071
版权

1.继承的概念及定义

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

//继承
class Person {
public:
	void Print()
	{
		std::cout << "name:" << name << std::endl;
		std::cout << "age:" << age << std::endl;
	}
protected:
	std::string name = "老爹";
	int age = 18;
};
//    派生类 继承方式  基类
class Child :public Person
{
public:
protected:
};
int main()
{
    Child ch;
    ch.Print();
    return 0;
}

1.1继承关系和访问限定符

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

总结：

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

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

3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他 成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。 4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过 最好显示的写出继承方式。

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

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

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

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

//基类
class Person
{
public:
	std::string _name;
	int _age;
	std::string _sex;
};
//派生类
class Child:public Person
{
public:
	int _number;
};

int  main()
{
	Child ch;
	//1、派生类的对象可以赋值给基类的对象/指针/引用
	Person p1 = ch;
	Person* p2 = &ch;
	Person& p3 = ch;

	ch = p1;//2、基类的对象不能赋值给派生类

//注意：p2是基类，ch是子类
	p2 = &ch;
	Child* ch2 = (Child*)p2;//3、基类的指针可以这样强制类型转换赋值给派生类
	ch2->_number;

//注意：p2是基类，p1也是基类
	p2 = &p1;
	Child* ch3 = (Child*)p2;//4、基类的指针这样强制类型转换赋值给派生类，访问会越界
	p2->_number;//越界



	return 0;
}

3、继承中的作用域

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

2、子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏， 也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

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

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

class Person
{
public:
	void Print(int a)
	{
		std::cout << "基类" << std::endl;
	}
};
class Child:public Person
{
public:
	//1、函数名与基类函数名相同构成隐藏，参数类型不同不影响
	void Print(double b)
	{
		std::cout << "派生类" << std::endl;
		//2、可以显示调用(类名+函数名)
		Person::Print(1);
	}
};

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

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

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

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

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能 保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构

小思考：1、先调用派生类的构造函数可能会出现怎么样的问题？

               2、先调用基类的析构函数可能会出现怎么样的问题？

//基类
class Person
{
public:
	//构造函数
	可以对const char*强制类型转换成string
	Person(std::string name )
		:_name(name)
	{
		std::cout << "Person( std::string name)" << std::endl;
	}
	//拷贝构造
	Person(const Person& pe)
	{
		_name = pe._name;
		std::cout << "Person(const Person& pe)" << std::endl;
	}
	//赋值重载
	Person& operator=(const Person& pe)
	{
		if (this != &pe)
		{
			std::cout << "Person& operator=(const Person& pe)" << std::endl;
			_name = pe._name;
		}
		return *this;
	}
	~Person()
	{
		std::cout << "~Person()" << std::endl;
	}
private:
	std::string _name;
};
class Child :public Person
{
public:
	
	Child(std::string name,int num)
		:Person(name)//1、派生类的构造要显示的调用基类的构造
		,_num(num)
	{
		std::cout << "Child(std::string name,int num)" << std::endl;
	}
	Child(const Child& ch)
		:Person(ch)//2、派生类拷贝构造要调用基类的拷贝构造，因为派生类继承了基类的变量，然后派生类的对象也可以给基类对象赋值（切割）
		,_num(ch._num)
	{
		std::cout << "Child(const Child& ch)" << std::endl;
	}
	Child& operator=(const Child& ch)
	{
		if (this != &ch)
		{
			Person::operator=(ch);//3、派生类赋值重载要调用基类的赋值重载，理由同2
			_num = ch._num;
			std::cout << "Child& operator=(const Child& ch" << std::endl;

		}
		return *this;
	}
	~Child()
	{
		std::cout << "~Child()" << std::endl;
	}

private:
	int _num;
};

可以看出，先调用基类，在调用派生类

可以看出，析构函数先调用派生类，再调用基类

小思考：析构为什么会调用两次？

5、继承与友元（友元函数）

  • 友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
class Child;//这句是声明Child类，不能会报错
class Person
{
protected:
    std::string _name;
public:
	//友元函数
    friend void Display(const Person& p,const Child&c);
	
};

class Child :public Person
{
	protected:
	int _num;
};
void Display( const Person& p,const Child&c)
{
	std::cout << p._name << std::endl; //可以编译通过
	std::cout << c._num << std::endl;//这个会报错
}
int main()
{
	Person p;
	Child c;
	Display(p, c);
	return 0;
}

6、继承与静态成员

  • 基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子 类，都只有一个static成员实例。
class Person
{
public:
	Person()
	{
		_num++;
	}
public://注意：如果是私有限定符外面访问不到
	static int _num;//统计人数
};
 int Person::_num = 0;//初始化

class Studer:public Person
{
private:
	std::string _name;//人名
};
class Graduate:public Person
{
private:
	int _graduate;//研究生人数
};

int main()
{
	Studer s1;
	Studer s2;
	Studer s3;

	Graduate g;
	std::cout << Person::_num << std::endl;//4
	Person::_num = 0;
	std::cout << Person::_num << std::endl;//0
	return 0;
}

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

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

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

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

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。 在Assistant的对象中Person成员会有两份

//棱形继承问题的引出
class Person
{
public:
	std::string _name;//名字
};

class Student:public Person
{
public:
	int _id;//学号
};
class Teacher:public Person
{
public:
	int _tid;//职位工号
};
class Assistant:public Student,public Teacher
{
public:
	std::string majorCourse;
};
int main()
{
	Assistant a;
	Person p;
	p._name = a._name;//会产生二义性,是选Student的_name,还是选Teacher的_name,是不清楚的。

    //这样指明了赋谁的值，数据的冗余还是没有解决。这时候可以引入虚拟继承virtual
	a.Student::_name="aaa";
	a.Teacher::_name="bbb";
	return 0;
}

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

class Person
{
public:
	std::string _name;//名字
};

class Student:virtual public Person
{
public:
	int _id;//学号
};
class Teacher:virtual public Person
{
public:
	int _tid;//职位工号
};
class Assistant:public Student,public Teacher
{
public:
	std::string majorCourse;
};
int main()
{
	Assistant a;
	Person p;
	p._name = a._name;//无二义性和冗余问题
	
	return 0;
}

虚拟继承解决数据冗余和二义性的原理

给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成 员的模型

class A
{
public:
	int _a;
};
        /*public A*/
class B:virtual public A
{
public:
	int _b;
};
         /*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

下面是上面的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 = "桂A00001"; // 车牌号
   };
   
   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 = "桂A00002"; // 车牌号
    Tire _t; // 轮胎
   };

思考：1. 什么是菱形继承？菱形继承的问题是什么？

           2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的

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

重零出发
关注
初识Java
ad5889的博客
04-21 966
在学习Java前 让我们了解它有什么用吧。
初识云计算
最新发布
qq_71207842的博客
09-11 1645
混合云是公有云和私有云两种服务方式的结合。另一个好的理念是，使用公有云作为一个选择性的平台，同时选择其他的公有云作为灾难转移平台。公有云的最大意义是能够以低廉的价格，提供有吸引力的服务给最终用户，创造新的业务价值，公有云作为一个支撑平台，还能够整合上游的服务（如增值业务，广告）提供者和下游最终用户，打造新的价值链和生态系统。此外，由于混合云是不同的云平台、数据和应用程序的组合，因此整合可能是一项挑战。随着云计算的发展，如今，几乎每个企业计划或正在使用云计算，但不是每个企业都使用相同类型的云模式。
c++继承
晴空的博客
02-21 259
继承中的特点 有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。 1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private 2.protected 继承：基类 public 成员，protected 成员，privat...
C++继承中的特点
SanShuiGeGe的博客
07-24 373
C++继承中的特点 有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。 1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private 2.protected 继承：基类 public 成员，protected 成员，privat...
C++继承及其特点
BoKe
08-10 4661
继承 继承机制是面向对象程序设计，使代码可以复用最重要手段，它允许在保持原有类的基础上进行扩展，增加功能，这样产生的类，叫做派生类，被派生类继承的类叫做基类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认知过程。 继承方式 派生类名字： 继承权限：父类的名字 例如：已存在类class A 那么派生类定义为 class Derived: public A 继承权限三种格式...
C++类继承中的特点
V_Vi3w
03-12 214
继承中的特点 有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。 1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private 2.protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private 3.private
C++语言之继承中的特点
ctrigger的专栏
01-16 224
有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。 1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private 2.protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private 3.pr
Class的继承和原型链关系：深入理解继承和多态
# 第一章：初识Class与原型链 ## 1.1 Class的概念和特点 在面向对象的编程语言中，Class是一种定义数据结构和行为的模板。它可以包含数据属性和方法，通过实例化的方式创建对象，并且支持继承和多态等特性。 ```...
一、初识GVR ---- Android VR视频/Google VR for Android /VR Pano/VR Video
热门推荐
光光的博客
08-04 1万+
AndroidVR入门教程 Daydream Cardboard
初识 UVM：引言和基本概念介绍
# 第一章：UVM 简介 当涉及到 UVM（Universal Verification Methodology）时，人们常常感到困惑，但实际上它是一个...它继承了 OVM（Open Verification Methodology）和 VMM（Verification Methodology Manual）的优
C++特性——继承
love10_1314的博客
07-03 188
学习C++有一段时间了，今天就来总结一下C++的第二个特性——继承。 首先介绍一下继承的概念，所谓的继承就是用已有的类（基类），根据实际需要定义新的类（派生类）的过程，其实质是代码复用。继承关系如下图所示： 继承的语法结构： 类标识 派生类类名：继承方式：基类类名 ...
C++的继承及其特点、原则
qq_33907392的博客
09-05 1218
最近在学习C++，因为之前有一定C语言基础，所有学起来还不算太难。 C++与C语言最大的不同，就是继承、多态与封装，这也是学习C++需要着重掌握的地方。 会了继承、多态和封装，基本就会了面向对象的方式，也更能体会面向对象与面向过程的不同。 继承 继承是面向对象语言中的一个重要的概念，可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。 ...
C++的特质——继承
逃离那片云的博客
09-25 415
C++的三大特质： 继承、多态、封装
C++三大特征之继承
Pluto_God的博客
01-14 209
C++有三大特征，封装、继承与多态，在本篇文章中，与大家来聊一聊继承。 继承的本质就是代码的复用。简单的说，继承是指一个对象直接使用另一对象的属性和方法。 C++中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。 1.在C++中派生来（子类）继...
C++三大特性之继承
qq_54866651的博客
06-03 92
派生类自身的成员，内置类型不处理，自定义类型调用它的默认构造，继承基类的成员，如果有默认构造函数，自动调用，没有则需要在初始化列表显示调用基类的构造函数初始化。实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。，增加功能，这样产生新的类，称派生类。
C++的三大特性之继承
zhengyawen666的博客
01-31 520
C++继承以及相关的概念
C++学习一多继承以及特点
HotIce0
02-04 726
C++中存在多重继承和多继承，两者名字相近却是完全不同的两个概念： 多重继承：是至少有一个派生类又作为基类被继承。例如A——派生——B ，B——又派生——C。这就是最简单的多重继承。 多继承 ：是一个派生类继承了两个基类； 例如： class Man :public Worker,public Person { public: Man(string name,string code):W
C++三大特性-继承
水澹澹兮生烟
09-01 632
一.继承的概念及定义
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值