C++继承

一.概念

1.1 什么是继承

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

class Person
	{
	public:

		void print()
		{
			cout << _name << " " << _age << endl;
		}
	protected:
		int _age = 22;
		string _name = "zhc";
	};

	//继承父类的成员后，父类的成员函数和成员变量都会成为子类的一部分，这里体现了Student类和Teacher类复用了Person类的成员，下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。
	class Student : public Person
	{
	protected:
		int _stuNum;
	};

	class Teacher : public Person
	{
	protected:
		int _jobNum;
	};

	Person p;
	Student s;

	s.print();

1.2继承的定义格式

我们以上述的代码为例，其中Person是父类，也称基类，Student是子类，也称派生类

二.继承方式和访问限定符之间的关系

2.1继承方式

有三种继承方式，它们分别是public继承，protected继承，private继承

2.2访问限定符 

同样的，类成员有三种访问限定符，它们分别是public访问，protected访问，private访问

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

        子类继承父类的成员，有三种继承方式，而父类中的成员又有三种固有的访问方式，这样子当子类采用不同的继承方式继承父类中的不同访问方式的成员后，子类对于父类中的成员就拥有了不同的访问方式，以下表为例。

总结：

1.    基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员虽然被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.    基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的，它在继承时才会起作用。
3.    实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public  > protected > private。
4.    使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5.    在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

 三.基类和派生类对象赋值转换+

在基类和派生类对象赋值转换过程中，要注意以下几点：

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

 演示代码如下：

void Test()
{
	class Person
	{
	public:

		void print()
		{
			cout << _name << " " << _age << endl;
		}
	protected:
		int _age = 22;
		string _name = "zhc";
	};

	//继承父类的成员后，父类的成员函数和成员变量都会成为子类的一部分，这里体现了Student类和Teacher类复用了Person类的成员，下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。
	class Student : public Person
	{
	public:
		Student()
		{
			_age = 23;
			_name = "auc";
		}
	public:
		int _stuNum;
	};

	class Teacher : public Person
	{
	protected:
		int _jobNum;
	};

	Person p;
	p.print();
	Student s;
	//派生类对象可以赋值给 基类的对象 / 基类的指针 / 基类的引用。
	//这里有个形象的说法叫切片或者切割。
	//寓意把派生类中父类那部分切来赋值过去。
	p = s;
	Person& p1 = s;
	Person* p2 = &s;
	p.print();
	p1.print();
	p2->print();

	//基类对象不能赋值给派生类对象
	s = p;

	//基类的指针可以通过强制类型转换赋值给派生类的指针。
	//但是必须是基类的指针是指向派生类对象时才是安全的
	Student* s1 = (Student*)&p; //这里的Person类对象p是由Student类对象s赋值构造产生的，也就是说p与s无关，所以当强制类型转换之后，会有越界访问的风险
	s1->_stuNum = 0;

	Student* s2 = (Student*)p2;//这里的Person类指针p2是指向Student类对象s中的基类部分，也就是说p2与s有关，所以当强制类型转换之后，不会有越界访问的风险
	Student* s3 = (Student*)&p1;
	s2->_stuNum = 0;
	s3->_stuNum = 0;
}

 四.继承中的隐藏

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

void Test()
{
	class Person
	{
	public:
		void func()
		{
			cout << "Person::func()" << endl;;
		}
	protected:
		int _age = 22;
		string _name = "zhc";
		int _Num = 100;
	};

	class Student: public Person
	{
	public:
		void func()
		{
			cout << "Student::func()";
		}

		void print()
		{
			//Student的_Num和Person的_Num构成隐藏关系
			cout << _Num << endl;
			cout << Person::_Num << endl;
		}
	protected:
		int _stuNum;
		int _Num = 120;
	};

	Student s1;
	s1.print();

	//Student的成员函数func和Person的成员函数func构成隐藏关系
	s1.func();
	s1.Person::func();
}

五.子类的默认成员函数

一个类由6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？
（1）派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
（2） 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
（3） 派生类的operator=必须要调用基类的operator=完成基类的复制。
（4） 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
（5）派生类对象初始化先调用基类构造再调派生类构造。

那什么情况下，才需要自己写子类的四个重要的默认构造函数呢？

（1）父类没有默认构造函数，需要我们自己写构造

（2）如果子类由资源需要释放，就需要自己显示写析构

（3）如果子类存在浅拷贝问题，就需要自己写拷贝构造和赋值重载函数

 

void Test()
{
	class Person
	{
	public:
		Person(int age, const string& name)
			:_age(age),_name(name)
		{
			cout << "Person(int age, const string& name)" << endl;
		}
		~Person()
		{
			cout << "~Person()" << endl;
		}

		Person(const Person& p)
			:_age(p._age)
			,_name(p._name)
		{
			cout << "Person(const Person& p)" << endl;
		}

		Person& operator=(const Person& p)
		{
			_age = p._age;
			_name = p._name;
			cout << "Person& operator=(const Person& p)" << endl;
			return *this;
		}
	protected:
		int _age;
		string _name;
	};

	class Student : public Person
	{
	public:
		Student()
			:Person(22, "zhc")//由于Person类没有默认构造函数，需要显式调用Person的构造函数
			,_stuNum(100)
		{
			cout << "Student()" << endl;
		}
		~Student()
		{
			cout << "~Student()" << endl;
		}

		Student(const Student& s)//在写子类的拷贝构造函数的时候，需要调用父类的拷贝构造
			:Person(s)
		{
			_stuNum = s._stuNum;
			cout << "Student(const Student& s)" << endl;
		}

		Student& operator=(const Student& s)//在写子类的赋值重载函数的时候，需要调用父类的赋值重载函数
		{
			_age = s._age;
			_name = s._name;
			_stuNum = s._stuNum;
			cout << "Student(const Student& s)" << endl;
		}
	protected:
		int _stuNum;
	};

	Student s1;
	Person p1(23, "auc");
	p1 = s1;
	Person p2 = s1;
}

六.小知识

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

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

七.多继承引发的菱形继承问题

7.1什么是菱形继承问题

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

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

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

但是菱形继承会引起重复继承同一个父类，这对于子类来说，就造成了数据冗余和二义性，以下图进行说明：

由上图可知，Person类被重复继承了，这就造成数据冗余，然后如果Assistant对象直接访问Person类中的数据就会产生二义性报错，因为编译器不知道访问的是student类的父类，还是访问teacher类的父类。

void Test()
{
	class Person
	{
	public:
		int _age = 22;
		string _name = "zhc";
	};

	class Student: public Person
	{
	public:
	protected:
		int _stuNum;
	};

	class Teacher : public Person
	{
	public:
	protected:
		int _jobNum;
	};
	
	class Assistant : public Student, public Teacher
	{
	public:
		string _course;
	};
	
	//这里会有二义性的问题，因为不知道访问的是哪一个
	Assistant a;
	a._name = "auc";

	//这里二义性问题解决了，但是会造成数据冗余
	a.Teacher::_name = "auc";
	a.Student::_name = "auc";

}

7.2虚拟继承解决菱形继承 

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

void Test()
{
	class Person
	{
	public:
		int _age = 22;
		string _name = "zhc";
	};

	class Student: virtual public Person
	{
	public:
	protected:
		int _stuNum;
	};

	class Teacher : virtual public Person
	{
	public:
	protected:
		int _jobNum;
	};
	
	class Assistant : public Student, public Teacher
	{
	public:
		string _course;
	};
	
	Assistant a;
	a._name = "auc";

}

7.3菱形继承解决数据冗余和二义性的原理

 我们借助内存窗口观察对象成员模型，来研究菱形继承解决数据冗余和二义性的原理

void Test()
{
	class A
	{
	public:
		int a;
	};

	class B :virtual public A
	{
	public:
		int b;
	};

	class C :virtual public A
	{
	public:
		int c;
	};

	class D :public B, public C
	{
	public:
		int d;
	};

	D d;
	d.A::a = 1;
	d.B::a = 2;
	d.b = 3;
	d.c = 4;
	d.d = 5;
}

下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。 

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

7.4总结

        多继承是C++的一种缺陷，也是C++复杂的一种体现，有了多继承，就会有菱形继承的问题，有了菱形继承的问题，就会有菱形虚拟继承来解决该问题，这样子，底层实现就更加复杂了，所以一般不建议使用多继承

八.继承和组合

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

void Test()
{
	//Person类和Student类构成继承关系，也就是说学生是一个人
	class Person
	{
	public:
		int _age = 22;
		string _name = "zhc";
	};

	class Student: public Person
	{
	public:
	protected:
		int _stuNum;
	};


	//轮胎类和车辆类是组合关系，车辆包含轮胎，但是车辆不是轮胎
	class tyre//轮胎
	{
	public:
		int weight;
		int diameter;
	};

	class car//车辆
	{
	public:
		int License_Num;
		string brand;
		tyre t;
	};
}