C++面向对象之----多态
多态
- 多态
-
- 多态构成条件
- 虚函数
-
- 虚函数的重写
- C++11 override 和 final
- 函数重载，虚函数的覆盖，继承中隐藏的区别
- 抽象类
- 多态的原理
-
- 虚表的打印
- 静态绑定与动态绑定
- 多继承中的虚表
- 总结
生活中我们是否会见到这样的场景，比如说我们想要去某个景区玩玩，再买票的时候，门口就有着学生半价，成人是全票，小孩免费什么的。对于这种场景，我们肯定不会对每一种人群写一个专门的函数，这样代码的复用性就变得很差。
这个时候就需要使用多态来解决
多态
通俗的来说，多态就是一个事物的多个形态。当我们想要实现某个功能时，对于这个功能的不同对象都有着不同的状态。
这有个常见的例子，就是买票。经常会看的成人全票，学生证半价的情况。针对这种情况，定义两个多态的成员类
class People
{
public:
virtual void BuyTicket()
{
cout << "成人，买全价票" << endl;
}
};
class Student:public People
{
public:
virtual void BuyTicket()
{
cout << "学生，买半价票" << endl;
}
};
函数调用的方法
void Buy(People* Pobj)
{
Pobj->BuyTicket();
}
void text1()
{
People Pobj;
Student Sobj;
//成人
Buy(&Pobj);
//学生
Buy(&Sobj);
}
结果
多态构成条件
- 必须通过父类的指针或者引用调用虚函数
- 被调用的函数必须是虚函数（virtual），并且子类必须对父类的虚函数进行重写
虚函数
被virtual修饰的类成员函数称为虚函数
class People
{
public:
virtual void BuyTicket()
{
cout << "成人，买全价票" << endl;
}
};
虚函数的重写
虚函数的重写也叫做虚函数的覆盖，就是在子类中有一个跟父类完全相同的虚函数。
也就是子类的虚函数与父类的虚函数返回值类型，函数名字，参数列表完全相同，称子类的虚函数重写了父类的虚函数
class Student:public People
{
public:
virtual void BuyTicket()
{
cout << "学生，买半价票" << endl;
}
};
注意：子类在重写虚函数的时候，函数前是可以不用加virtual关键字，但是子类继承的父类是一定要加virtual关键字的。
虚函数重写的两个例外
- 协变（子类和父类虚函数的返回值类型不同）
子类在重写父类虚函数的时候，和父类虚函数返回值类型不同。也就是父类虚函数返回父类对象的指针或者引用，而子类虚函数返回子类对象的指针或者引用。
class A
{};
class B : public A
{};
class People
{
public:
virtual A* BuyTicket()
{
cout << "成人，买全价票" << endl;
return nullptr;
}
};
class Student :public People
{
public:
virtual B* BuyTicket()
{
cout << "学生，买半价票" << endl;
return nullptr;
}
};
也就是子类与父类虚函数的返回值可以不相同，但是这个返回值必须也是一个继承的关系，父类返回父类，子类返回子类
2. 析构函数的重写
可以发现，当我们的父类是用子类强转过来的对象时，在进行析构函数的过程中，只是析构了切片后的父类，没有析构剩余子类部分。这里没有报错是因为类中并没有指针类型的成员变量。
这个时候就需要使用虚函数使析构函数构成多态，虽然析构函数中子类和父类的函数名看上去不同，不满足构成多态的条件，但实际上，编译后析构函数的名称统一都是destructor。
这个时候，只需要让子类与父类的析构函数也满足多态，等待调用析构函数的时候，其实是从虚表中找到各自的析构函数，然后调用。
C++11 override 和 final
如果我们定义一个虚函数，我们不想让他满足继承关系，这个时候就可以使用C++11中的这两个关键字
- final ，修饰虚函数，表示这个虚函数不能被继承
2. override，检测子类虚函数是否重写了父类的某个虚函数，如果没有重写就会报错
不加override，编译器没有报错，这时构成了隐藏，不是重写
函数重载，虚函数的覆盖，继承中隐藏的区别
抽象类
抽象，也就是那些看起来很奇怪的事情，很难理解的事物。
我们在虚函数的后面加一个=0，那么这个函数就构成了纯虚函数。包含纯虚函数的类叫做抽象类，也叫接口类。抽象类不能实例化出对象，他只是一个声明，没有定义。
想要让抽象类发挥作用，只能在子类中重写该纯虚函数，利用子类来实例化出对象
//抽象类
class computer
{
public:
virtual void Brand() = 0;
};
//子类进行实例化
class DELL :public computer
{
public:
virtual void Brand()
{
cout << "Dell 戴尔" << endl;
}
};
class Mac :public computer
{
public:
virtual void Brand()
{
cout << "Mac" << endl;
}
};
抽象类的实现可以看成一种接口继承
接口继承，就是纯虚函数的基础，子类继承的是父类的虚函数接口，子类的目的就是为了重写而达到多态，子类继承的是接口
实现继承，普通函数的基础都是实现的继承，子类继承了父类的函数，可以对继承的函数进行使用或者重写，他继承的是函数的实现。
多态的原理
通过调试，可以看到在这个类的成员中，多了一个指针，而这个指针指向的是一个指针数组的地址。
除了_P成员，还多一个__vfptr放在对象的前面，对象中的这个指针我们叫做虚函数表指针 (v代表virtual，f代表function)。
一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表
虚表的打印
我们可以用一个函数指针来完成对虚表的打印工作，利用int*来取对象的前四个字节，然后再进行解引用，最后把这个int型的数据转为函数指针的类型。
有时候，这个虚表的结尾可能不是一个0，所以可能会存在打印好多地址的情况。
虚表中存储的是每个虚函数的地址，当我们让子类继承父类的时候，其实在子类的虚表中存储的是子类中虚函数的地址，如果发生了重新，那就换成重写后的虚函数的地址，没有重写，那么就是父类虚函数的地址。
如果子类中还有自己的虚函数，那么这个虚函数在虚表中的位置是在父类虚函数的后面
而对于多态而言，当我们把子类对象的指针强转为父类对象时，同时被转过去的还有这个虚表，然后调用父类的对应虚函数时，其实调用的函数是虚表中子类重写的函数，这个时候就可以完成多态的功能。对于不同的情况，完成不同的操作。
虚函数时存在虚表中的，而虚表中存储的是函数的地址，在我们的程序中函数的地址都是存在代码段中的，所以虚表也是在代码段中的
就像上面Show函数作为一个普通的函数，他的地址就是在代码段中，我们通过打印，发现Show函数的地址和虚表中函数的地址比较接近，所以可以判断出，虚表存在于代码段
静态绑定与动态绑定
- 静态绑定，这是在编译期间就确定了程序的行为，就像函数重载一样
- 动态绑定，是在程序运行期间，根据具体的类型决定程序的具体行为，然后调用具体的函数（所以不是模板，模板不是调用具体函数，而是推演），也就是多态了
多继承中的虚表
多继承设计的三个类
class Student
{
public:
virtual void BuyTicket()
{
cout << "学生，买半价票" << endl;
}
virtual void StudentFun4()
{
cout << "StudentFun4()" << endl;
}
protected:
int _S;
};
class Teacher
{
public:
virtual void BuyTicket()
{
cout << " 教师, 三折" << endl;
}
virtual void TeacherFun4()
{
cout << "TeacherFun4()" << endl;
}
};
class Grade : public Student, public Teacher
{
public:
virtual void BuyTicket()
{
cout << "团体折扣" << endl;
}
virtual void GradeFun4()
{
cout << "GradeFun4()" << endl;
}
};
我们可以看到。多继承中，子类自己的虚函数在第一个继承的父类虚表的后边
总结
·多态·就是一个事物的多个形态。当我们想要实现某个功能时，对于这个功能的不同对象都有着不同的状态
而对于inline函数和static函数，他是不能成为虚函数的
- inline函数，由这个关键字声明的函数，在编译期间就会被编译器展开，所以说inline函数是没有地址的，也就不能被写到虚表中，因此不能构成多态
- static函数，由static定义的函数，因为他是没有this指针的，所以使用
类名::成员函数的方法是无法访问虚表的，因此也不能放在虚表中
至于为什么多态在调用的时候，必须是子类的指针或者引用类型，而不能是普通类型？
我们构成多态，是利用了this指针中的虚表，但是当我们使用普通赋值的时候，却发现实际上是调用了父类的构造函数，重新构造了一个父类，并不是切片的过程。
所以说，如果使用普通的赋值，就会造成赋值过去的变量的虚表和原本的虚表不同
所以说，使用指针类型或者引用类型，使得在强制类型转换的时候，使用切片的操作，就会完成多态