【C++】继承

1. 继承的概念及定义

若要设计一个学校中不同人员的身份管理系统，首先需要将其身份信息数据提取出来封装成一个类，比如：

不难发现，每个类中都包含了一些公共的属性信息，后续还有一些类要包含这些属性，写起来非常麻烦，而且后续需要修改这些公有属性的话每个类都要一起改，可维护性和可扩展性比较低，针对这种情况，C++设计出了继承。

1.1 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类(也叫子类)，而被扩展的类称之为基类(也叫父类)。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前接触的复用都是函数复用，继承是类设计层次的复用。

1.2 继承的定义

针对上面的类，可以把公有属性提取出来，作为父类，其余需要该属性的类可继承该父类：

//基类(父类)
class People {
public:
	void printPeoInfo() {
		cout << "name : " << _name << endl;
		cout << "age : " << _age << endl;
		cout << "address : " << _address << endl;
	}
protected:
	// 公有属性
	string _name;
	size_t _age;
	string _address;
};

//派生类(子类)
class Student : public People {
public:
	Student(const char* name = "", size_t age = 0, const char* address = "", int id = 0) {
		_name = name, _age = age, _address = address, _stuid = id;
	}
	void StuPrintPeoInfo() {
		printPeoInfo();
		cout << "id : " << _stuid << endl;
	}
private:
	//独有属性
	int _stuid; // 学号
	//...
};

//派生类(子类)
class Teacher : public People {
public:
	Teacher(const char* name = "", size_t age = 0, const char* address = "", int id = 0) {
		_name = name, _age = age, _address = address, _jobid = id;
	}
private:
	//独有属性
	int _jobid; // 工号
	//...
};
int main()
{
	Student s("lzh", 19, "xxxx");
	s.StuPrintPeoInfo();
	Teacher t("xxx", 40, "ddd");
	t.printPeoInfo();
	return 0;
}

继承后People类中的成员函数+变量就成了子类的一部分了，但是继承父类的成员与继承方式和类中的访问限定符有很大关系。

1.3继承关系和访问限定符以及组合关系

分别分为以下三种：

每种继承方式都可以和其余三种访问限定符进行组合，也就是会有如下九种不同的组合状态：

类成员/继承方式	public继承	protected继承	private继承
父类的public成员	成为子类的public成员	成为子类的protected成员	成为子类的private成员
父类的protected成员	成为子类的protected成员	成为子类的protected成员	成为子类的private成员
父类的private成员	子类中不可见	子类中不可见	子类中不可见

其中最常用的只有子类public继承父类的public和protected成员。

public和protected成员的区别：

在此之前private和protected访问限定符的作用是没有区别的，用来限制成员只能在类中被访问，外部无法直接访问。
到继承这里才会有区别，被private修饰的成员被子类继承也无法访问，若需要让子类访问，则要用protected限定符。

注意：子类只包含父类的成员变量，成员函数依旧在公共的代码段

总结：

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

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

通常而言，不同类类型的对象之间是不允许相互赋值的，除非重载了对应的运算符，但是对于父类和子类的对象之间进行赋值有着不同的规则。

class People {
protected:
	string _name = "peter";
	size_t _age = 18;
};

class Student : public People {
private:
	int _stuid;
};

int main()
{
	People p;
	Student s;
	s = p;
	p = s;
	return 0;
}

上述语句，若把将父类对象赋值给子类对象时会报错，但是把子类对象赋值给父类对象是可以的。

通常把第一种情况，即父类对象赋值给子类对象称之为向下转换
第二种情况，把子类对象赋值给父类对象称为向上转换

对于第一种情况，是语法的规定，硬要说则可以理解为子类对象有的成员父类没有，无法赋值，而第二种赋值是发生了赋值兼容或者叫做切割(切片)，把子类中继承的父类成员切割出来赋值给父类的对象，其余属于子类的成员则被丢弃了，并且赋值过程中没有发生隐式类型转换。

证明是否发生隐式类型转换：

此时rp是s中父类对象的引用，那么修改rp会影响s吗

执行后结果：

不仅是父类的引用，父类的指针也可以修改s中父类对象的成员。

特性总结：

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

3. 继承中的作用域

子类和父类中若出现了同名成员时会发生什么？

class People {
public:
	void print() {
		cout << _num << endl;
	}
	string _name = "peter";
	int _num = 10;
};

class Student : public People {
public:
	void print() {
		cout << _num << endl;
	}
	int _num = 20;
};

int main()
{
	Student s;
	s.print();
	return 0;
}

输出的结果是子类中的_num，没有报错，这是因为两个成员隶属于不同的类域，不同的域中可以出现同名的变量，虽然子类继承了父类的成员，但一样不受影响，因为这里有一个特殊的语法，即子类和父类出现了同名成员时，子类会对其进行隐藏(也叫重定义)，因此编译器会优先在子类域中查找。

编译器的查找规则遵循就近原则，先在当前局部域(函数体)中找_num，找不到去子类域找，找不到再去父类域中找，还找不到就去全局找，再找不到就报错了，也可以指定去命名空间中找。

如果就是想访问父类中的_num时需要指定父类域：

class Student : public People {
public:
	void print() {
		cout << People::_num << endl;
	}
	int _num = 20;
};

同样父类的成员函数也被隐藏了，如何调用父类的print函数呢，也是在调用的时候指定：

s.People::print();

对其中一个print做一下修改，此时这两个print函数构成什么？

class People {
public:
	void print() {
		cout << _num << endl;
	}
	string _name = "peter";
	int _num = 10;
};

class Student : public People {
public:
	void print(int i) {									   
		cout << _num << endl;
	}
	int _num = 20;
};

它俩构成隐藏或重定义，而非函数重载，函数重载是在相同作用域时出现的同名函数且参数不同时构成重载，但此时它俩属于不同的作用域，自然没有重载这一概念，隐藏是在父子类域中只要成员函数名字相同就会构成。

特性总结：

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

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

子类与普通类的默认成员函数有什么区别？

先定义一个父类，让子类继承：

class Person {
public:
	Person(const char* name = "peter")
		: _name(name) {
		cout << "Person()" << endl;
	}

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

	Person& operator=(const Person & p){
		cout << "Person operator=(const Person& p)" << endl;
		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 num = 0)
		: _name(name)
		, _num(num) {
		cout << "Student()" << endl;
	}
protected:
	int _num; //学号
};

int main()
{
	Student s;
	return 0;
}

子类继承了父类的成员，那么子类的构造函数能否能通过初始化列表来初始化父类的成员呢？

结果是不可以的，子类只能初始化自己的成员，语法规定不能再子类构造函数里的初始化列表中初始化父类的成员，但是在函数体中是可以的，因为在函数体中叫做赋值而不是初始化。

那父类的成员是如何初始化的呢？

事实上每创建一个子类对象时，编译器都会去自动调用父类的默认构造函数，初始化父类的成员。

如果没有默认构造时会报错，除非显式传参调用，但是调用方法与普通类还有一些区别：

class Student : public Person {
public:
	Student(const char* name = "张三", int num = 0)
		: Person(name)
		,_num(num) {
		cout << "Student()" << endl;
	}
protected:
	int _num; //学号
};	

调用方式类似于创建一个匿名对象，这样就可以把参数传递给父类的构造函数来初始化它的成员。

注意初始化顺序，如果是子类则第一个初始化的永远是先初始化父类对象

拷贝构造：

Student(const Student& s)
	: Person(s._name)
	, _num(s._num) {
	cout << "Student(const Student& s)" << endl;
}

上述语法报错，父类中没有参数为string的构造函数，对于构造函数，父类对象要去调用父类的默认构造，对于拷贝构造也是同样的道理，需要去调用父类的拷贝构造，子类调用子类的拷贝构造。

既然子类中的父类对象要去调用父类的拷贝构造，那就需要传递一个父类的对象，但是只有子类对象怎么办？

这里调用父类的拷贝构造可以直接传递子类对象s，因为传递过程中会发生切割(切片)，会把属于子类的成员切割出去，然后把父类对象的成员交给一个父类对象的引用。

Student(const Student& s)
	: Person(s)
	, _num(s._num) {
	cout << "Student(const Student& s)" << endl;
}

如果不显示调用父类的拷贝构造，那么编译器会自动去调用默认构造，如果没有就会报错。

赋值重载：

Student& operator=(const Student& s) {
	if (this != &s) {
		Person::operator=(s);
		_num = s._num;
	}
	return *this;
}

对于子类中的父类对象，直接显式去调用它的赋值重载，同样传递子类对象s，会自动切割出父类对象。
还有一点由于两个类的赋值重载函数名相同，构成隐藏，因此需要用父类类名来指定是父类中的赋值重载，不然会引发无穷递归。

对于子类成员，手动赋值即可。

以上行为若不是公有继承会出现问题，所以建议都要有公有继承

析构函数：

~Student() {
	Person::~Person();
}

若要显示调用父类的析构函数则需要在前面指定，因为由于后面多态的原因，所有的析构函数的函数名都被编译器统一处理成了destructor，这样便构成了隐藏，因此需要指定父类的析构。

但是这种写法最后析构的结果是不正确的：

明明只定义了一个子类对象其中包含一个父类对象，因此应该只需要析构一次，但是结果析构了两次，原因是因为父类对象的析构函数不需要手动调用，编译器在调用完子类对象的析构函数后会自动去调用父类的析构函数，编译器要保证对象的析构顺序，不能让父对象先析构，因为子对象是有可能还要用到父对象的成员的，而父对象不可能会用到子对象的成员，所以先析构子后父。

构造对象 时永远是先父后子

特性总结：

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

5. 继承与友元

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

//声明Student类
class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
	//正确
	cout << p._name << endl;
	//报错
	//无法访问子类成员
	cout << s._stuNum << endl;
}
int main()
{
	Person p;
	Student s;
	Display(p, s);
}

很好理解，因为父亲的朋友不是我的朋友

若想访问子类成员，则把该函数声明为子类的友元即可。

6. 继承与静态成员

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

class Person{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;

class Student : public Person{
protected:
	int _stuNum; // 学号
};

int main()
{
	Person p;
	Student s;
	Student s;
	//3
	cout << p._count << endl;
}

静态成员属于父类，被子类继承后也属于子类了，但是它不存储在任何一个父子类对象中，只是每个对象都可以访问它。

被继承后并没有在子类中拷贝，只是继承了该静态成员的使用权

再父类中定义一个静态成员，并在构造函数中对该成员进行自增，便可统计出一共构造了多少个父类和子类对象，因为子类必须要调用父类的默认构造。

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; // 主修课程
};

int main()
{
	Assistant as;
}

菱形继承后该类对象的对象模型如下：

可以发现的是一个Assistant对象中包含了Student和Teacher类对象，并且这两个父类对象中又都保存了一份它们的父类对象Person类，这便造成了数据冗余问题，因为相同的属性的对象成员，在一个对象中只保存一份就好。除此之外，还会出现二义性，即通过Assistant对象去访问Person类中的成员时会报错，编译器不知道要去使用Student对象中的还是Teacher对象中的那个Person对象成员。

针对二义性问题，可以通过类名+域作用限定符去指定访问，而对于数据冗余性的解决方法就比较复杂了，需要用到虚拟继承。

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。

class Person {
public:
	void print() {
		cout << "person" << endl;
	}
	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; // 主修课程
};

通过虚拟继承，会使得共同父类Person的成员变量在子类Assistant中只存一份，从而避免了数据冗余。同时，也可以解决函数调用冲突的问题。

virtual要加在继承路径中子类共同的父类前面，并且virtual可与继承方式public互换位置

注意：虚拟继承仅在共同父类需要解决数据冗余和函数冲突的场景中使用，在其它普通继承关系中不需要使用。

7.1 虚拟继承的底层原理：

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

class A {
public:
	int _a;
};
class B : public A {
public:
	int _b;
};
class C : 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类中的成员变量增加，则对应d中保存的两份A类成员变量的也会一起增加，大大提高了数据的冗余。

而如果采用虚拟继承时，对象在内存中的变化：

与非虚拟继承的区别在于，原本两个存放_a的位置都改成了一串数字，_a的实际位置则位于_d的下方，这样整个d对象就只有一份A类的成员变量_a，这个_a同时属于B和C，那么它们是如何去找到这个公共的_a成员呢？

答案是分别通过B和C中存放的那串数字，这两个数字本质是两个指针，叫做虚基表指针，分别指向一块区域，那块区域被称为虚基表，虚基表中存的偏移量，通过偏移量可以找到下面的_a。

虚基表中保存的数据：

虚基表的前四个字节是用来存放其它信息数据，而后面四个字节则存放的有效数据，这实际上是一个偏移量(相对距离)，对应的是B和C类成员在d对象中的地址，分别加上这个偏移量后所达到的位置就是那个公共的_a成员存储的地址。

存放虚基表指针的位置也可以直接用来存放到_a的相对距离，但为什么没有这么设计而是通过虚基表指针去虚基表中再去取到对应的偏移量呢？

这是因为成员变量不一定只有一个，若有多个的话B和C中都要存A类的每个成员的地址，这种做法很浪费空间，因此把公共成员对应的偏移量全部存放到其它位置，再为每一个需要访问这些公共成员的对象配备一个指针指向这块空间，若要访问可以通过该指针去取出对应的偏移量。

而一个指针的大小只有4//8个字节，相较于把偏移量存放在每个对象中的做法大大减少了空间的消耗，同时，因为相对距离是确定的，所以多个D类对象都可以复用这张虚基表。

虚继承后，不仅D类的对象模型发生了变化，B和C类的对象模型也发生了变化，它们的模型结构都是相同的，也会存在一份虚基表指针和虚基表，因此虚基表的另一个作用在于，若发生了切割时，被切出来的对象也可以通过虚基表指针去虚基表取出对应的偏移量来找到我的成员所在的位置，统一了处理步骤。

8. 继承的总结和反思

1. C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
3. 继承和组合

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

优先使用对象组合，而不是类继承 。

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。

组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。