继承的定义及概念

概念

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

一句话就是一个类将共同属性全部提取出来，这就是父类。另一个类通过继承可以实现对于这些父类成员函数和函数变量的使用。就好像是有一部武功秘籍，家族独门绝技。你可以从父辈的指点得以学习，同时以外获得一本葵花宝典。这时你就有了自己家中独门绝技还有另外的功法。

定义

在这里插入图片描述
上面就是对于继承的语法说明，通过子类创建对象调用就会报错。因为继承和类的权限有关。类中的继承不显示权限，默认就是私有的。类的继承就需要指定权限来。在继承标志位之后，父类名之前加上继承权限说明。
在这里插入图片描述
使用后就可以调用父类中的成员函数。不同权限继承使用到的父类中成员的权限也就不同

总结：

1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected >private。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5.在实际运用中一般使用都是public继承。

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

父类的和子类可以转换，派生类可以赋值给基类对象、基类的指针、基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。但是父类对象不能给派生类对象赋值。基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

这个也可以使用那本武学秘籍来理解，对于学成归来的你，此时已经名声大噪，这时有人找你学艺。也想学习你家族的独门秘籍，但是你在学习武学时就已经被告知家族武学不能外传，正当你准备拒绝时。来人就拿出了你的家族信物。见此物如见家主。这就是指针，还有引用。毕竟这都是证明。这是指同一个身份。然后他便拿出家主让转交给你的武学秘籍。这是你就会对比对比是否是和你自身所学的武学相同。这时就是是否指向你子类的指针。

class KongFu
{
public:
	void cheats1()
	{
		cout << "family cheats" << endl;
	}
private:
	int pre=1;
};

class person:public KongFu
{
public:

private:
	int self=2;
};

int main()
{

	person p;
	KongFu kf;

	KongFu p0 = p;//子类对象给父类对象赋值
	KongFu* p1 = &p;//赋值给父类对象指针
	KongFu& p2 = p;//赋值给父类的引用

	p1 = &p;//确保指向子类
	person* q = (person*) p1;//赋值子类，强制类型转换
	//p = kf;//error，父类对象不能给子类对象赋值
	
	return 0;
}

继承后的作用域

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

class person:public KongFu
{
public:
	void cheats1()
	{
		cout << "persona cheats" << endl;
	}
private:
	int self=2;
};

这个就是子类函数与父类函数构成函数隐藏关系，默认就是就近原则在对象调用时会调用子类的函数。如果要进行父类成员的访问就必须指定作用域，对于使用函数就行域的一个指定。
在这里插入图片描述

派生类默认的6个成员函数该何去何从？

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
派生类的operator=必须要调用基类的operator=完成基类的复制。
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
派生类对象初始化先调用基类构造再调派生类构造。
派生类对象析构清理先调用派生类析构再调基类的析构。
因为后续一些场景析构函数需要构成重写（多态），重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

总结：对于父类成员调用父类的，子类调用子类的。各自做各自的事。

构造函数：

class Person
{
public:
	Person(const char* name="jack")
		:_name(name)
	{
		cout << "preson()" << endl;
	}
	~Person()
	{
		cout << "~person" << endl;
	}
public:
	string _name; 
};
class Student : public Person
{

public:
	Student(const char* name ,int num)
		:Person(name)
		,_num(num)
	{
		cout << "student()" << endl;
	}

	~Student()
	{
		cout << "~student()" << endl;
	}

protected:
	int _num;
};


int main()
{
	Student("rose", 20);

	return 0;
}

在这里插入图片描述

对于子类与父类的构造、析构函数函数顺序不同。main函数调用是一个栈帧，就符合栈的特性FILO，继承时的先后顺序就是函数的声明顺序。声明顺序决定调有点顺序。所以对于栈空间的释放顺序就是照入栈顺序的。含有一种理解就子类中有父类的成员，如果先释放父类就可能造成野指针问题。对于父类析构后，子类依然会访问到父类的空间。其实前者理解更加具有说服力。

多继承

对于一个类有时不得不使用多继承方式，就比如一个人身兼数职，对于不同场景的职务不同，头衔名称就会有变化。
在这里插入图片描述

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