【C++干货铺】继承 | 多继承 | 虚继承

这篇具有很好参考价值的文章主要介绍了【C++干货铺】继承 | 多继承 | 虚继承。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

=========================================================================

个人主页点击直达:小白不是程序媛

C++系列专栏:C++干货铺

代码仓库:Gitee

=========================================================================

目录

继承的概念及定义

继承的概念

继承的定义

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

基类和派生类的赋值转化 

继承中的作用域

 派生类的默认成员函数

构造函数

拷贝构造函数

赋值重载 

 析构函数

继承和友元

继承和静态成员

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

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

继承的总结


继承的概念及定义

继承的概念

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

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

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

继承的定义

定义格式

下面我们看到Person父类,也称作基类Student子类,也称作派生类

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

继承关系和访问限定符

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

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

类成员/继承方式  public继承  protected继承  private继承
基类的public成员 派生类的public成员 派生类的protected
成员
派生类的private
成员
基类的protected
成员
派生类的protected
成员
派生类的protected
成员
派生类的private
成员
基类的private成
在派生类中不可见  在派生类中不可见 在派生类中不可见

 总结:

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 Person
//class Student : private Person
class Student : public Person
{
public:
	void Pinrt()
	{
		cout << _name << _age << endl;
		cout << _stunum << endl;
	}
protected:
	int _stunum; // 学号
};

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承


基类和派生类的赋值转化 

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

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

class Person
{

protected:
	string _name;
	string _sex;
	int _age;
};
class Student : public Person
{
protected:
	int _No;
};
int main()
{
	Student S;
	Person P = S;
	Person* PP = &S;
	Person& ppp = S;
	//基类通过强制转化赋值给派生类
	Student* PS = (Student*)PP;
	//
	return 0;
}

继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员,子类成员将屏蔽父类对同名成员的直接访问,这种情况叫隐藏,也叫重定义。(在子类成员函数中,可以使用 基类::基类成员 显示访问)
3. 需要注意的是如果是成员函数的隐藏,只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员

//继承中的作用域
class Person
{
protected :
	int _num = 1;
};
class Student : public Person
{
public:
	void Print()
	{
		cout << _num << endl;
		cout << Person::_num << endl;
	}
protected:
	int _num = 2;
};
int main()
{
	Person P;
	Student S;
	S.Print();
	return 0;
}

 【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

class Person
{
public:
	void func()
	{}
};
class Student : public Person
{
public:
	void func(int)
	{

	}
};

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承


派生类的默认成员函数

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

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

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

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

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

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

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

7 因为后续一些场景析构函数需要构成重写,重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理,处理成destrutor(),所以父类析构函数不加virtual的情况下,子类析构函数和父类析构函数构成隐藏关系。

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承 【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

构造函数

class person
{
public:
	person(const char * name="")
		:_name(name)
	{}
protected:
	string _name;
};
class student : public person
{
public:
	student(const char* name,int a)
		:person(name)
		,_stuid(a)
	{}
protected:
	int _stuid;
};
int main()
{
	student s("张三", 18);
	return 0;
}

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

拷贝构造函数

class person
{
public:
	person(const char * name="")
		:_name(name)
	{}
	person(const person& p)
		:_name(p._name)
	{}
protected:
	string _name;
};
class student : public person
{
public:
	student(const char* name,int a)
		:person(name)
		,_stuid(a)
	{}
	student(student& s)
		:person(s)
		, _stuid(s._stuid)
	{}
protected:
	int _stuid;
};
int main()
{
	student s("张三", 18);
	return 0;
}

 【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

赋值重载 

class person
{
public:
	person(const char * name="")
		:_name(name)
	{}
	person(const person& p)
		:_name(p._name)
	{}
	person& operator=(const person& p)
	{
		if (this != &p)
		{
			_name = p._name;
		}
		return *this;
	}
protected:
	string _name;
};
class student : public person
{
public:
	student(const char* name,int a)
		:person(name)
		,_stuid(a)
	{}
	student(student& s)
		:person(s)
		, _stuid(s._stuid)
	{}
	student& operator=(const student& s)
	{
		if (this != &s)
		{
			person::operator=(s);
			_stuid = s._stuid;
		}
		return *this;
	}

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

 析构函数

class person
{
public:
	person(const char * name="")
		:_name(name)
	{}
	person(const person& p)
		:_name(p._name)
	{}
	person& operator=(const person& p)
	{
		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 a)
		:person(name)
		,_stuid(a)
	{}
	student(student& s)
		:person(s)
		, _stuid(s._stuid)
	{}
	student& operator=(const student& s)
	{
		if (this != &s)
		{
			person::operator=(s);
			_stuid = s._stuid;
		}
		return *this;
	}
	~student()
	{
		cout << "~student()" << endl;
	}
protected:
	int _stuid;
};

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承


继承和友元

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

class student;
class person
{
public:
	friend void Print(const person&p,const student&);
protected:
	int _age;
private:
	string _name;
};
class student : public person
{
public:
	//friend void Print(const person& p, const student&);
protected:
	int _stuid;
};
void Print(const person&p,const student& s)
{
	cout << p._age << p._name << s._stuid << endl;
}

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承


继承和静态成员

基类定义了static静态成员,则整个继承体系里面只有一个这样的成员。无论派生出多少个子
类,都只有一个static成员实例 。 


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

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

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

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

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

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

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

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

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

//多继承及解决多继承的虚继承
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";
}

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系,在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";
}

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

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

为了研究虚拟继承原理,我们给出了一个简化的菱形继承继承体系,再借助内存窗口观察对象成
员的模型。

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

下图是菱形继承的内存对象成员模型:这里可以看到数据冗余

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

下图是菱形虚拟继承的内存对象成员模型:这里可以分析出D对象中将A放到的了对象组成的最下
面,这个A同时属于B和C,那么B和C如何去找到公共的A呢?这里是通过了B和C的两个指针,指
向的一张表。这两个指针叫虚基表指针,这两个表叫虚基表。虚基表中存的偏移量。通过偏移量
可以找到下面的A。 【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承

下面是上面的Person关系菱形虚拟继承的原理解释:

【C++干货铺】继承 | 多继承 | 虚继承,c++,开发语言,继承,虚继承


继承的总结

1. 很多人说C++语法复杂,其实多继承就是一个体现。有了多继承,就存在菱形继承,有了菱
形继承就有菱形虚拟继承,底层实现就很复杂。所以一般不建议设计出多继承,一定不要设
计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是C++的缺陷之一,很多后来的OO语言都没有多继承,如Java。

3. 继承和组合

  • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
  • 组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象。
  • 优先使用对象组合,而不是类继承 。
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言:在继承方式中,基类的内部细节对子类可见 。继承一定程度破坏了基类的封装,基类的改变,对派生类有很大的影响。派生类和基类间的依赖关系很强,耦合度高。
  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse),因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系,耦合度低。优先使用对象组合有助于你保持每个类被封装。
  • 实际尽量多去用组合。组合的耦合度低,代码维护性好。不过继承也有用武之地的,有些关系就适合继承那就用继承,另外要实现多态,也必须要继承。类之间的关系可以用继承,可以用组合,就用组合。 

今天对C++中继承的介绍和分享到这就结束了,希望大家读完后有很大的收获,也可以在评论区点评文章中的内容和分享自己的看法。您三连的支持就是我前进的动力,感谢大家的支持!! !  文章来源地址https://www.toymoban.com/news/detail-753978.html

到了这里,关于【C++干货铺】继承 | 多继承 | 虚继承的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • c++—继承、继承方式

    1. c++三大核心功能     (1)封装:提高代码的维护性,遇到问题可以准确定位;     (2)继承:提高代码的复用性,注意不是ctrl+c,ctrl+v,而是不做任何修改或操作源码就能实现代码的复用;     (3)多态:提高代码的扩展性; 2. 代码复用的两种方式     (1)组合(ha

    2024年02月06日
    浏览(36)
  • C++三大特性—继承“复杂的菱形继承及菱形虚拟继承”

    C++的一个大坑:菱形继承 希望这篇文章能让你理解什么是菱形继承,以及菱形继承的注意事项 单继承:一个子类只有一个直接父类时称这个继承关系为单继承 多继承:一个子类有两个或以上直接父类时称这个继承关系为多继承  java语言不支持多继承,只支持单继承。 菱形

    2024年02月03日
    浏览(46)
  • 【C++进阶】继承、多态的详解(继承篇)

    作者:爱写代码的刚子 时间:2023.7.28 前言:本篇博客主要介绍C++进阶部分内容——继承,C++中的继承和多态是比较复杂的,需要我们认真去深挖其中的细节。 继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序

    2024年02月13日
    浏览(39)
  • C++(20):多重继承与虚继承

    多重继承 是指从多个直接基类中产生派生类的能力。多重继承的派生类继承了所有父类的属性。 在派生类的派生列表中可以包含多个基类: 每个基类包含一个可选的访问说明符。如果说明符被忽略掉了,则 class 对应的默认访问说明符是 private , struct 对应的是

    2024年02月10日
    浏览(38)
  • 【C++干货铺】C++中的四种类型转换

    ========================================================================= 个人主页点击直达:小白不是程序员 C++系列专栏:C++干货铺 代码仓库:Gitee ========================================================================= 目录 C语言中的类型转换 为什么C++需要四种类型转化 C++强制类型转换 static_cast reinter

    2024年01月25日
    浏览(47)
  • [开发语言][C++]:递增递减运算符

    递增运算符和递减运算符为对象的+1和-1提供了简洁的书写形式。 自增自减运算符的应用: 这两个运算符除了应用在算术运算,还可应用于迭代器,因为很多迭代器并不支持算术运算。 递增和递减运算符有两种书写形式:前置版本和后置版本。 前置版本 ++i --i :首先将运算

    2024年01月25日
    浏览(52)
  • 【C++干货铺】优先队列 | 仿函数

    ========================================================================= 个人主页点击直达: 小白不是程序媛 C++系列专栏: C++干货铺 代码仓库: Gitee =========================================================================   目录 优先队列(priority_queue )的介绍和使用 priority_queue的介绍 priority_queue的使用

    2024年02月05日
    浏览(28)
  • 【C++】C++中的继承

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

    2024年02月03日
    浏览(42)
  • 【c++】“谁想继承我的花呗-.-“继承的学习

        文章目录 前言 一、继承的语法 二、基类和派生类对象赋值转换 1.例子 2.继承中的作用域 3.派生类的默认成员 4.继承与友元 5.继承与静态成员 6.复杂的菱形继承和菱形虚拟继承 总结   继承 (inheritance)机制是面向对象程序设计 使代码可以复用 的最重要的手段,它允许程序

    2023年04月16日
    浏览(33)
  • 【巧妙继承】C++玩转继承的神级技巧

    🎉博客主页:.小智 🎉欢迎关注:👍点赞🙌收藏✍️留言 🎉系列专栏:C++终极篇 🎉代码仓库:小智的代码仓库 继承概念: 继承 (inheritance)机制是面向对象程序设计 使代码可以复用 的最重要的手段,它允许程序员在 保持原有类特性的基础上进行扩展 ,增加功能,这样产

    2024年02月13日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包