本篇来聊聊C++面向对象的第三大特性-多态。
1.多态的概念
多态通俗来说就是多种形态。多态分为编译时多态(静态多态)和运⾏时多态(动态多态)。
- 编译时多态：主要就是我们前⾯讲的函数重载和函数模板，他们传不同类型的参数就可以调⽤不同的函数，通过参数不同达到多种形态。
- 运⾏时多态：具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种形态。
我们重点要说的是运行时多态。运行时多态举个例子：买票的行为，学生买票是学生票，普通人买票是全价票，军人买票又是优先票...这就是买票行为的多种形态。
2.多态的定义及实现
2.1 多态的构成条件
实现多态还有 两个必须 重要条件：
- 必须是基类的指针或者引⽤调⽤虚函数
- 被调⽤的函数必须是虚函数，并且完成了虚函数重写/覆盖。
2.2 虚函数
class Adult //基类
{
public:
virtual void BuyTicket()
{
cout << "全价票" << endl;
}
};virtual在继承里也遇到过，在继承里出现是为了解决菱形继承问题，跟多态里virtual意义不同。
2.3 虚函数的重写/覆盖
class Student : public Adult //派生类
{
public:
virtual void BuyTicket()
{
cout << "学生票" << endl;
}
};2.3.1 多态的实例
void Ticket(Adult* pa) //基类的指针
{
pa->BuyTicket();
}前面说过，多态的第一个条件，必须是基类的指针或者引⽤调⽤，这里的pa满足；第二个条件，被调用函数必须是虚函数而且进行了虚函数的重写/覆盖，这里的BuyTicket函数满足条件。
int main()
{
Adult a; //基类对象
Student s; //派生类对象
Ticket(&a);
Ticket(&s);
return 0;
}
传不同的对象过去，得到的结果不同。
void Ticket(Adult& pa) //基类的引用
{
pa.BuyTicket();
}
int main()
{
Adult a; //基类对象
Student s; //派生类对象
Ticket(a);
Ticket(s);
return 0;
}
class Soldier : public Adult //派生类
{
public:
virtual void BuyTicket()
{
cout << "军人票" << endl;
}
};
然后只用Student和Soldier这两个派生类。
int main()
{
Student st; //派生类对象
Soldier so; //派生类对象
Ticket(st);
Ticket(so);
return 0;
}
2.3.2 对实例进一步解释
1.为什么一定是基类的指针或引用？在继承中我们说过派生类和基类的切片/切割问题，参数类型是基类可以保证实参传基类的对象也可以，传派生类的对象也可以。如果是派生类的指针或引用，基类对象根本传不过去。
2.对于Ticket函数的参数列表，按照我们在继承中的说法，不管传什么过去，调用的都是Adult的成员函数，因为此时pa是由参数类型决定的，与传过来的对象无关，但是，在多态中，pa与自己的类型无关，只与传过来的对象有关，指向谁，调用谁。
3.构成多态的两个条件必须都满足。
如果不满足其中一个条件，比如基类没有虚函数。
class Adult //基类
{
public:
void BuyTicket() //没有虚函数
{
cout << "全价票" << endl;
}
};
class Student : public Adult //派生类
{
public:
virtual void BuyTicket()
{
cout << "学生票" << endl;
}
};
void Ticket(Adult* pa) //基类的指针或引用
{
pa->BuyTicket();
}
int main()
{
Adult a; //基类对象
Student s; //派生类对象
Ticket(&a);
Ticket(&s);
return 0;
}此时不构成多态，pa就走继承那套逻辑，不管传什么都是调用基类的。
如果都是虚函数并且进行了虚函数的重写/覆盖，但是Ticket参数类型不是基类的指针或引用，依旧是不构成多态的。
class Adult //基类
{
public:
virtual void BuyTicket()
{
cout << "全价票" << endl;
}
};
class Student : public Adult //派生类
{
public:
virtual void BuyTicket()
{
cout << "学生票" << endl;
}
};
void Ticket(Adult pa) //不是基类的指针或引用
{
pa.BuyTicket();
}
int main()
{
Adult a; //基类对象
Student s; //派生类对象
Ticket(a);
Ticket(s);
return 0;
} 
所以一定要同时满足构成多态的两个条件。
2.3.3 多态的经典例题
下面程序运行的结果是什么？
class A
{
public:
virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
virtual void test() { func(); }
};
class B : public A
{
public:
void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main()
{
B* p = new B;
p->test();
return 0;
}
答案：B -> 1
有两个类，A是基类，B是派生类。A和B里有返回值、函数名、参数类型都相同的函数func，虽然在派生类B里面没有加virtual，在这里依然构成虚函数的重写（原因前面说过）。
p是B类的指针，因为B继承了A，所以B类的指针p可以调用test函数。
在类里，成员函数都有隐含的this指针，这个this指针类型是A* 不是B*，虽然继承到B来了，但这只是一种说法，并不是真的把A里的内容全拷贝一份给B，所以A继承下来成员函数this指针类型依然是A*。
所以，调用func函数的就是基类的指针。
而func又构成虚函数的重写，所以这里同时满足了构成多态的两个条件。既然构成了多态，p指向派生类B，所以func应该是B类重写的func。
但是虚函数的重写只会重写函数体部分，重写后的样子如下。
所以结果是 B -> 1 。
2.3.4 协变
class A {};
class B : public A {};
class Person
{
public:
virtual A* BuyTicket()
{
cout << "买票-全价" << endl;
return nullptr;
}
};
class Student : public Person {
public:
virtual B* BuyTicket()
{
cout << "买票-打折" << endl;
return nullptr;
}
};
void Func(Person* ptr)
{
ptr->BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(&ps);
Func(&st);
return 0;
}返回类型也可以是自己类型的指针或引用。
2.3.5 析构函数的重写
基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派⽣类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以基类的析构函数加了vialtual修饰，派⽣类的析构函数就构成重写。
class A
{
public:
virtual ~A()
{
cout << "~A()" << endl;
}
};
class B : public A {
public:
~B()
{
cout << "~B()->delete:" << _p << endl;
delete _p;
}
protected:
int* _p = new int[10];
};
// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能
//构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
int main()
{
A* p1 = new A;
A* p2 = new B;
delete p1;
delete p2;
return 0;
}2.3.6 override 和 final关键字
class Car
{
public:
virtual void Dirve()
{}
};
class Benz :public Car
{
public:
virtual void Drive() override
{
cout << "Benz" << endl;
}
};
int main()
{
return 0;
}如果不加override这个代码是检查不出错误的。
class Car
{
public:
virtual void Drive() final //不能被重写
{}
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz" << endl;
}
};
int main()
{
return 0;
}不想成员函数被重写，就加上final。
2.4 重载/重写/隐藏的对⽐
3.纯虚函数和抽象类
class Car //抽象类
{
public:
virtual void Drive() = 0; //纯虚函数
};纯虚函数不需要定义实现，只需要声明，但并不代表纯虚函数不能定义实现。抽象类不能实例化出对象。如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。
class Benz :public Car
{
public:
virtual void Drive() //重写纯虚函数
{
cout << "Benz" << endl;
}
};此时就没有父类的对象，只有派生类的，但是父类的指针和引用还是有的。
int main()
{
Car* pBenz = new Benz;
pBenz->Drive();
return 0;
}
4.多态的原理
4.1 虚函数表指针
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
protected:
int _b = 1;
char _ch = 'x';
};
int main()
{
Base b;
cout << sizeof(b) << endl;
return 0;
}答案：D.12
类的大小如何计算，在【C++】类和对象（上）：初识类和对象 中的 2.2 对象大小 有详细解释。
按照计算对象大小的规则，这里的结果应该是8，但为什么是12呢？因为除了_b和_ch成员，还多⼀个_vfptr放在对象的前⾯(注意有些平台可能会放到对象的最后⾯，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针（简称虚表指针）。
vf就是virtual function。这个指针在32位程序下大小为4，所以按照内存对齐规则，大小为12.
⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。这里的表其实就是一个数组，虚函数表也就是一个函数指针数组，虚函数表指针就是指向这个数组的指针。
比如我们现在再加一个虚函数，这个_vfptr就会多一个内容。
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
virtual void Func2()
{
cout << "Func2()" << endl;
}
void Func3() //不是虚函数
{
cout << "Func3()" << endl;
}
protected:
int _b = 1;
char _ch = 'x';
};
这里只会存放虚函数的指针，不是虚函数不会放在里面，func3就不再这个里面。
4.2 多态的原理
以下面这段代码为例。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:
string _name;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:
string _id;
};
class Soldier : public Person {
public:
virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:
string _codename;
};
void Func(Person* ptr)
{
ptr->BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sr;
Func(&ps);
Func(&st);
Func(&sr);
return 0;
}4.2.1 从理论上分析
有ps、st、sr三个对象，就有三个虚函数表，这三个虚表里存放着自己的虚函数。
多态中Func函数应该是指向谁调用谁。
从内存角度，这里的ptr“看到的”都是父类，因为传子类过去会切片。
在满足多态的条件下，运行时编译器会找_vfptr这个指针，然后通过这个指针去对应的虚函数表里去找虚函数的地址。不管传的ptr类型是什么，与类型无关，只与指向的对象有关。
4.2.2 从汇编角度观察
满足多态条件下的汇编，最终调的是 call eax 。
不满足多态时，把前面的代码父类中的virtual删除，就不满足了。
class Person //父类
{
public:
void BuyTicket() { cout << "买票-全价" << endl; }
private:
string _name;
};来看一下汇编。
不管传的ptr是什么，与对象无关，调用的都是父类的函数。
4.3 静态绑定与动态绑定
- 对不满⾜多态条件(指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调⽤函数的地址，叫做静态绑定。
- 满⾜多态条件的函数调⽤是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数的地址，也就做动态绑定。
// ptr是指针+BuyTicket是虚函数满⾜多态条件。
// 这⾥就是动态绑定，编译在运⾏时到ptr指向对象的虚函数表中确定调⽤函数地址
ptr->BuyTicket();
00CD3C72 mov eax,dword ptr [ptr]
00CD3C75 mov edx,dword ptr [eax]
00CD3C77 mov esi,esp
00CD3C79 mov ecx,dword ptr [ptr]
00CD3C7C mov eax,dword ptr [edx]
00CD3C7E call eax
// BuyTicket不是虚函数，不满⾜多态条件。
// 这⾥就是静态绑定，编译器直接确定调⽤函数地址
ptr->BuyTicket();
00603C72 mov ecx,dword ptr [ptr]
00603C75 call Person::BuyTicket (06015FFh) 
5.虚函数表更深入的讲解
- 基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。
- 派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。
本次分享见到这里，我们下篇见~
