C++中的继承

🌟🌟hello，各位读者大大们你们好呀🌟🌟
🚀🚀系列专栏：【C++的学习】
📝📝本篇内容：继承的概念及定义；基类和派生类对象赋值转换；继承中的作用域；派生类的默认成员函数；继承与友元；继承与静态成员；复杂的菱形继承及菱形虚拟继承；继承的总结和反思
⬆⬆⬆⬆上一篇：优先级队列priority_queue模拟实现
💖💖作者简介：轩情吖，请多多指教(> •̀֊•́ ) ̖́-

1.继承的概念及定义

1.1继承的概念

继承的机制是面向对象程序设计使代码可以复用的最重要手段，它允许程序员在保持原有类特性的基础上进行扩展，这样产生的类叫派生类。继承是类设计层次的复用。

1.2继承定义

1.2.1定义格式

Person是父类,也称作基类。Student是子类，也称作派生类。

1.2.2继承基类成员访问方式的不同

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

2.基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因为继承而出现的。
3.基类的私有成员都是不可见的。基类的其他成员在子类的访问方式==MIn(成员在基类的访问限定符，继承方式），public>protected>private继承
4.关键字class时默认的继承方式是private继承，struct时默认为public
5.在实际运用中一般使用都是public继承，几乎很少使用protected/private继承

2.基类和派生类对象赋值转换（建立在public继承方式）

1.派生类对象可以赋值给基类的对象/指针/引用。这里有个形象的说法叫做切片或切割。寓意把派生类中父类那部分切来赋值过去

#include <iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person()" << endl;
	}
	Person& operator=(Person& p)
	{
		cout << "Person的赋值重载" << endl;
	}

	Person(Person& p)
	{
		cout << "Person的拷贝构造" << endl;
	}

	void Print()
	{
		cout << "Person" <<endl;
	}
protected:
	int _a;
	int _b;
};

class Student:public Person
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	void Print()
	{
		cout << "Student" << endl;
	}
private:
	int _c;
	int _d;
};


int main()
{
	Student s;
	Person p1= s;
	Person& p2= s;
	Person* p3 = &s;

	return 0;
}

2.基类对象不能赋值给派生类对象
3.基类的指针或引用可以通过强转赋给派生类的指针或引用。但必须是基类的指针是指向派生类对象时才是安全的。这里的基类如果是多态类型，可以使用RTTI的dynamic cast来进行识别后进行安全转换。

3.继承中的作用域

1.在继承体系中基类和派生类都有独立的作用域
2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）

#include <iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person()" << endl;
	}
	Person& operator=(Person& p)
	{
		cout << "Person的赋值重载" << endl;
	}

	Person(Person& p)
	{
		cout << "Person的拷贝构造" << endl;
	}

	void Print()
	{
		cout << "Person" <<endl;
	}
protected:
	int _a;
	int _b;
	int _x=10;
};

class Student:public Person
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	void Print()
	{
		cout << "Student" << endl;
		cout << _x << endl;
	}
private:
	int _c;
	int _d;
	int _x=20;
};

int main()
{
	Student s;
	s.Print();
}

如下是显示访问
3.如果是成员函数的隐藏，只需要函数名相同就构成隐藏
上面代码中的Print就是很好的例子

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

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用
我相信细心的同学应该已经发现上面做的测试中，已经证明了这个概念

也可以以这种方式显示调用

#include <iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person()" << endl;
	}
	Person(int a)
	{
		cout << "Person()" << endl;
	}
	Person& operator=(Person& p)
	{
		cout << "Person的赋值重载" << endl;
	}

	Person(Person& p)
	{
		cout << "Person的拷贝构造" << endl;
	}

	void Print()
	{
		cout << "Person" <<endl;
	}
protected:
	int _a;
	int _b;
	int _x=10;
};

class Student:public Person
{
public:
	Student()
		:Person(1)
	{
		cout << "Student()" << endl;
	}
	void Print()
	{
		cout << "Student" << endl;
		cout << Person::_x << endl;
	}
private:
	int _c;
	int _d;
	int _x=20;
};

int main()
{
	Student s;
}

2.派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
3.派生类的operator=必须调用基类的operator=完成基类的赋值


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



5.派生类对象析构先调用派生类析构再调用基类的析构
6.派生类对象初始化先调用基类构造再调用派生类构造
7.因为后续一些场景析构函数需要重写，重写的条件之一是函数名相同，那么编译器会对析构函数名进行特殊处理，处理成destructer（），所以父类析构函数不加virtual的情况下，子类析构函数和父类函数构成隐藏关系。

5.继承与友元

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

6.继承与静态成员

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

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		_count++;
		cout << "Person" << endl;
	}
	static int _count;
protected:
	int _a;
	
};
int Person::_count = 0;
class Student:public Person
{
public:
	Student()
	{
		_count++;
		cout << "Student" << endl;
	}
};
class Citizen :public Student
{
public:
	Citizen()
	{
		_count++;
		cout << "Citizen" << endl;
	}
};
int main()
{
	Citizen c;
	cout << Citizen::_count << endl;

	return 0;
}

当定义一个Citizen对象时，会调用构造函数，在其初始化列表中会调用Student的构造函数，在Student的构造函数中又会调用Person的构造函数，因此会调用三次构造函数，而构造函数中我进行了静态成员变量的++,最后结果为3，也证明了只有一个static成员实例的结论

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

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

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

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

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

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

一个人怎么可能会有两个名字呢，或者再举个例子，里面的是性别，一个人不可能会有两个性别，因此造成了数据冗余的问题。此时要使用virtual，通过菱形虚拟继承来解决这个问题
为了更好地探究这个问题，我们使用一个更简单的代码

#include <iostream>
using namespace std;
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;
}

通过调试中的内存窗口中发现，原来B,C应该存储A的位置似乎变成了一个地址，而A单独跑到了下面去，实际上冗余和二义性问题的内存位置会变成两个指针，指向一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存在偏移量


再次使用调试中的内存窗口，去查看存储的地址到底是什么，我们可以发现，地址所指向的位置四个字节是00000000，后面的四个字节是一个值，其实就是偏移量，可以计算一下，B中地址所指向的偏移量为20（十六进制14转换成十进制为20），然后计算一下在对象d中存储A部分的地址减去存储B部分的地址，结果会为20


对于C部分中也是这样处理的，并且对于同一类型的所定义的对象，其虚基表是共享的

8.继承的总结和反思

一般不建议设计出多继承，一定不要设计出菱形继承，太过复杂并且性能下降
public继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
继承：白箱复用，在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
组合：对象组合要求被组合的对象具有良好的定义接口。这种复用风格被称为黑箱复用。因为对象内部细节是不可见的。组合之间没有很强的依赖关系，耦合度低。

🌸🌸C++继承的知识大概就讲到这里啦，博主后续会继续更新更多C++的相关知识，干货满满，如果觉得博主写的还不错的话，希望各位小伙伴不要吝啬手中的三连哦！你们的支持是博主坚持创作的动力！💪💪