多态的概念

  简单的来说多态就是多种形态（好解释），多态是指在进行某种行为时，根据完成对象的不同完成时会产生不同的状态。
  举个例子，买车票，都是买票这个行为，A买的商务座，B买的一等座，C买的二等座，D买的无座。
  多态是在不同继承关系的类对象中调用同一函数，产生不同的行为。

多态的实现及定义

多态构成的条件

  继承中构成多态的必要条件：
    1.必须通过基类的指针或者引用调用虚函数；
    2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写；
    3.虚函数的重写必须要保证函数名、参数、返回值相同。
  派生类对应的函数可以不用加virtual，但是基类必须加virtual。派生类可以继承基类的接口，直接重写实现就可以。

#include <iostream>using namespace std;class Person {
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}virtual ~Person(){cout << "~Person()" << endl;}
};
class Student : public Person
{
public:void BuyTicket(){cout << "买票-半价" << endl;}~Student(){cout << "~Student" << endl;}
};
void Func(Person* p)
{p->BuyTicket();delete p;
}
int main()
{Func(new Person);printf("\n");Func(new Student);return 0;
}

虚函数

  被virtual修饰的类成员函数就被称为虚函数。

class Person {
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}virtual ~Person(){cout << "~Person()" << endl;}
};

虚函数的重写

  虚函数的重写（覆盖）：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名、参数列表完全相同），称子类的虚函数重写了基类的虚函数。

#include <iostream>using namespace std;class Person {
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}
};
class Student : public Person
{
public:
// 虽然这里不写virtual也可以，但是这不规范，建议加上virtual void BuyTicket(){cout << "买票-半价" << endl;}
};
void Func(Person* p)
{p->BuyTicket();
}
int main()
{Func(new Person);printf("\n");Func(new Student);return 0;
}

虚函数重写的两个例外

协变

  派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的对象的指针或者引用时，称为协变。

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

析构函数的重写

  派生类和基类析构函数的名字不相同，但是如果加了virtual，它们仍然是虚构函数。不过这里编译器做了一些特殊处理，编译之后析构函数的名字会被统一改成destructor。

重载、覆盖（重写）、隐藏（重定义）的对比

  重载：两个函数在同一作用域，函数名相同参数不同。
  覆盖（重写）：两个函数分别在基类和派生类的作用域，函数名、参数、返回值都必须相同（协变例外），两个函数必须是虚函数。
  隐藏（重定义）：两个函数分别在基类和派生类的作用域，函数名相同，两个基类和派生类的同名函数不构成重写就是重定义。

抽象类

概念

  在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化处对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口的继承。

class Car
{
public:virtual void Drive() = 0;
};
class Benz : public Car
{
public:virtual void Drive(){cout << "Benz-舒适" << endl;}
};
class BMW : public Car
{virtual void Drive(){cout << "BMW-操控" << endl;}
};
int main()
{Car* pBenz = new Benz;pBenz->Drive();Car* pBMW = new BMW;pBMW->Drive();return 0;
}

接口继承和实现继承

  普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
  虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以不实现多态，不要把函数定义成虚函数。

多态的原理

虚函数表

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
private:int _b = 1;char _ch;
};
int main()
{cout << sizeof(Base) << endl;Base b;return 0;
}

  根据上图，我们可以看出b出来自身的成员_b和_ch外，还有个_vfptr（不同的平台_vfptr放的位置并不相同，v代表virtual，f代表function），_vfptr是一个指针，被我们叫做虚函数表指针。
  一个含有虚函数的类中至少会有一个虚函数表指针，因为虚函数的地址被存放在虚函数表中，虚函数表也简称为虚表。

class Base
{
public:virtual void Func1(){cout << "BAse::Func1()" << endl;}virtual void Func2(){cout << "Base::Func2()" << endl;}void Func3(){cout << "Base::Func3()" << endl;}
private:int _b = 1;
};
class Derive : public Base
{
public:virtual void Func1(){cout << "Derive::Func1()" << endl;}
private:int _d = 2;
};
int main()
{Base b;Derive d;return 0;
}

  派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
  基类b对象和派生类d对象虚表是不一样的，Func1完成了重写，所以d的虚表中存的是重写Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。Func2继承下去后是虚函数，所以放进了虚表，Func3也继承了下来，但是不是虚函数，所以不会放进虚表。
  虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后会放一个nullptr。派生类虚表的生成过程为：先将基类中的虚表内容拷贝一份到派生类虚表中，如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表基类的虚函数，最后派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

多态的原理

  在p指向Mike时，p->BuyTicket在Mike的虚表中找到的是虚函数Person::BuyTicket。在p指向Johnson时，p->BuyTicket在Johnson的虚表中找到的虚函数是Student::BuyTicket。
  满足多态的函数调用，不是在编译时确定的，而是在运行起来会后在对象中去调用的。不满足多态的函数调用，在编译时就被确定好了。

动态绑定与静态绑定

  静态绑定又称为前期绑定（早绑定），在程序编译期间确定了程序的行为，也称为静态多态。函数重载就是一种静态绑定。
  动态绑定又称为后期绑定（晚绑定），是指在程序运行期间，根据具体的类型确定程序的具体行为，调用具体函数，也称为动态多态。