衔接继承总结

继承的概念和定义，基类和派生类对象赋值转换，这点可以去学学。

一般子类继承级就用公有继承。

继承中的作用域就了解一下就OK。

虚拟继承半了解就行。
我们自己设计尽量不要用菱形继承。但是可以用多继承。

继承和组合

继承是有复用。组合是相互独立。

优先使用对象组合，

白箱复用

继承这种通过生成派生类的复用称为白箱复用。因为基类的内部细节对子类可见，这样这一定程度破坏了封装。基类的改变，对派生类影响很大。派生类和基类的依赖关系很强，耦合度高。

黑箱复用

黑箱复用对象的内部细节不可见。没有很强的依赖关系，耦合度低。
实际中多去使用组合，耦合度低，代码维护性好。

学软件工程一定要画UML图。
要学会画类图。

C只要不修改公有.就不会影响D。
对象组合是类继承之外的另一种复用的选择。
C对象公有成员D不能直接用。
C对象保护成员D不能直接用。

多态的概念

多态就是：同一个对象去调用同一个函数时会产生不同的效果。

多态的关键字是：virtual
在函数面前加上virtual就实现了多态。

构成条件：
1.是虚函数+virtual
2.函数名/参数/返回值相同，构成重写,重写也叫作覆盖。

注意：要和继承的隐藏区分开，隐藏是没有+virtual。

多态有两个要求；
1.子类虚函数重写父类的虚函数。(重写就是三同+virtual)
(三同就是参数，返回值，函数名相同)
2.必须用父类指针或者引用去调用虚函数。

为什么要用父类的？不能用子类的？因为只有父类的话，传参的话，符合对象赋值兼容的规则。

不能用普通对象调用。

假如用普通对象调用，调用的都是普通对象的，也就是普通人的票。
这点为什么不同呢？可以看下面的多态的实现原理。

多态的定义以及实现

怎么让不同的对象调用不同的函数，这里涉及到对象赋值转换，切割。

#include <iostream>
using namespace std;
//普通票
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票——全价" << endl;
	}
};
//学生票 继承普通人
class Student :public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票——半价" << endl;
	}
};
//教师票 继承普通人
class Teacher : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票——免费" << endl;
	}
};

void Pay(Person* ptr)
{
	ptr->BuyTicket();
}
int main()
{
	Person p;
	Student s;
	Teacher t;
	Pay(&t);

	return 0; 
}

虚函数重写的两个例外

协变

这个是C++的缺陷。

首先满足协变，需要是对象

Student继承了Person,假如返回值不同，三同中的返回值不同。
子函数需要加virtual,这是好习惯。

class A
{

};
class B :public A
{

};
class Person
{
public:
	virtual A* f()
	{
		cout << "virtual A* Person::f()" << endl;
		return new A;
	}
};
class Student : public Person
{
public:
	virtual B* f()
	{
		cout << "virtual B* Student::f()" << endl;
		return new B;
	}
};

面试题

接口继承。
子类 继承 重写父类虚函数
把virtual继承了下来，缺省参数也继承了下来。

1.接口继承（所以B中func不写virtual也是虚函数，复合多态条件，缺省参数也是用的A::func的1）

2.重写的函数实现。

析构函数的重写

析构函数+virtual构成重写，析构函数的名字统一会被改成destructer

基类的析构函数一般要定义为虚函数，定义为虚函数可以完成析构函数的重写。这样可以不容易导致析构的时候发生错误。

final

final中文叫做最后，可以理解为：最后的类。
1.在函数后面添加final关键字，修饰虚函数，表示该函数不能被重写
2.在基类的后面加final，表示该类不能被继承。

voerride

override是写在子类中的，用于检查子类是否完成了重写，如果没有完成重写，就会报错。
比如：
1.忘记加了virtual
2.函数仓鼠不同。

重载

1.两个函数在同一作用域
2.函数名/参数不同

隐藏(重定义)

隐藏针对的是两个普通函数
1.两个函数分别在基类和派生类的作用域
2.函数名相同
3.两个基类和派生类的同名函数不构成重写就是重定义(隐藏)。

重写(覆盖)

1.两个函数分别在基类和派生类的作用域
2.函数名/参数/返回值必须相同(协变除外)
3.两个函数必须是虚函数。

抽象类

概念：C++中的包含有纯虚函数的类就叫做抽象类，抽象类的不能实例化处对象。

子类继承抽象类，必须重写虚函数，才能实例化对象。

什么是抽象类？

抽象的意思就是：在现实中一般没有对应的实体。
举个例子：

不能实例化出来对象。比如在学校中，人不是具体的实体，而老师和学生是具体的实体。

所以人就是抽象类。

抽象类间接要求子类必须重写，才能实例化对象。

实现继承和接口继承

实现继承：普通函数的继承是实现继承。继承的是函数的实现，也就是函数体。

接口继承：虚函数的继承是接口继承，继承的是虚函数的参数/函数名/返回值，继承的是接口，目的是为了重写，达成多态。

所以不重写，不实现多态，就不要写虚函数。

多态的原理

多态就是实现指针指向哪儿，调用哪的。
怎么实现的呢？

虚函数表

虚函数表里面存放的是虚函数的指针。

父类的对象模型是：
1.指向虚函数表的指针。
2.成员变量

子类的对象模型：
1.从父类继承下来的指针和变量
2.自己的变量

不同的是子类的虚函数表，在子类的虚函数表中，继承下来的重写的函数不一样。

子类中重写的函数覆盖了父类的函数。

这就说明重写：是语法层的概念，对函数实现进行了重写。
原理层的概念：就是子类的虚表，拷贝父类的虚表，然后覆盖重写的那个虚函数。

那多态的调用是怎么实现的呢？

多态调用的实现，依靠运行时决议，去指向对象的虚表中查看调用函数的地址。

普通函数的调用：编译时决议，编译时确定调用函数的地址。

、
指向谁我在谁的虚表里找到调用的。
父类赋值给子类对象，也可以切片，为什么实现不了多态？

为什么对象实现不了多态。只有指针和引用可以实现。

原理：编译器很死板，在编译的时候就确定了，编译器在检查时发现不构成多态，

怎么才能让对象可以支持多态？对象是不可以的。

动态绑定和静态绑定

1.在程序编译期间确定了程序的行为，
2.构成多态就叫做动态绑定，也叫晚绑定，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体函数

切片的区别。

对象的切片是把子类中父类的值，拷贝过去，自定义类型是深拷贝。
但是不拷贝虚表指针，因为都指向了同一个虚函数表。导致混乱，不知道调用谁。

对象切片的时候，子类只会拷贝成员给父类对象，不会拷贝虚表指针，假如拷贝就混乱了，父类对象中到底是父类的虚表指针，还是子类的虚表指针？到底该调用谁就混乱了。

但是多态是指向谁调用谁，这不就混乱了，父类指向子类调用的还是子类。所以对象不可能实现多态。

但是引用和指针切片的话就是直接指向父类或引用父类的那一部分，不存在拷贝的苦恼。

多态的两种形态？

静态的多态：函数重载。
为什么有静态的多态，重载实际是在编译期间，根据函数名修饰规则找到不同的函数。

动态的多态：就是上面所讲的。是在运行时候去指向的虚函数表找，而实现的两种形态。

单继承中的虚函数表

虚函数理论而言要进虚表，但如果只有子类有的虚函数，监视窗口只有父类的虚表，难道子类只有的虚函数不进虚表吗？编译器规定，虚函数都要进虚表的，但是子类一般是拷贝父类的的虚表，然后重写需要重写的虚函数进行覆盖。因为监视窗口一般都是骗人的。但在内存中可以看到。

为了验证这个现象，我们可以写一段程序来打印虚表。

虚函数表是一个数组，数组里的每一个元素是函数指针。

这里说明vs的监视窗口看到的虚函数表不一定是真实的，可能会被处理过。

虚表存在哪个区域？

同一个类型的对象，共用一个虚表。

所以虚表存在的区域只有静态区(数据段)或常量区(代码段)。
那么到底在哪个区域呢。
常量区
常量区更加合理，因为静态区一般是全局变量.

我们也可以打印来验证，会发现虚标的地址和常量区的地址最为接近。

多继承中的虚函数表

多继承中虚函数表中虚函数的位置

派生类的未重写的虚函数会放在继承的第一个基类部分的虚函数表。