参考C++：多态 详解_c++多态-CSDN博客
C++多态——虚函数_c++的a* a = new b()是什么意思-CSDN博客
一.多态的概念
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了 Person。 Person 对象买票全价， Student 对象买票半价。
二.多态的定义及实现
2.1 重写/覆盖（动态多态）
重写/覆盖： 子类中有一个跟父类完全相同的虚函数，子类的虚函数重写了基类的虚函数
即：子类父类都有这个虚函数 + 子类的虚函数与父类虚函数的 函数名/参数/返回值 都相同 -> 重写/覆盖（注意：参数只看类型是否相同，不看缺省值）
2.1.1 两个要求
- 被调用的函数必须是虚函数，子类对父类的虚函数进行重写 （重写：三同（函数名/参数/返回值）+虚函数）
- 父类指针或者引用去调用虚函数。
2.1.2 虚函数
常见使用方法：
A *a = new B();
a->func();// 在这里，a虽然是指向A的指针，但是被调用的函数(func)却是B的!若func()为虚函数，则优先调用B中的func()
若func()为不为虚函数，则优先调用A中的func()
若A *c = *a；c->func()；同上
若A d = *a；d.func()；则只执行A中的func() 原因：强制转化为A对象的空间，和B无关。
#include <iostream>
using namespace std;
class A{
public:
virtual void Who(){
cout << "I'm A" << endl;
cout << "*********************************" << endl;
}
};
class B :public A{
public:
virtual void Who(){
cout << "I'm B" << endl;
cout << "*********************************" << endl;
}
};
void test(A *a){
cout << "test *a" << endl;
a->Who();
}
void test(B *b){
cout << "test *b" << endl;
b->Who();
}
void test(A a){
cout << "test a" << endl;
a.Who();
}
void test(B b){
cout << "test b" << endl;
b.Who();
}
int main(){
B b;
A *a = &b; //等同于：A *a = new B();
a->Who(); //输出 I'm B
b.Who(); //输出 I'm B
test(a); //调用test(A *a),输出 I'm B
test(*a); //调用test(A a),输出 I'm A
test(b); //调用test(B b),输出 I'm B
test(&b); //调用test(B *b),输出 I'm B
}只需要在父类中使用virtual关键字即可
class A{
public:
virtual void foo();
};
class B: public A{
public:
void foo(); // 没有virtual关键字!
};
class C: public B{ // 从B继承，不是从A继承！
public:
void foo(); // 也没有virtual关键字！
};这种情况下，B::foo()是虚函数，C::foo()也同样是虚函数。因此，可以说， 基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。
class A{
public:
void foo() { bar();}
private:
virtual void bar() { ...}
};
class B: public A{
private:
virtual void bar() { ...}
};在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar()的override不起作用的情况。
这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。
2.1.3 纯虚函数
如下声明表示一个函数为纯虚函数：
class A{
public:
virtual void foo()=0; // =0标志一个虚函数为纯虚函数
};一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为， 实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数
2.1.4 虚析构函数
析构函数也可以是虚的，甚至是纯虚的。例如：
class A{
public:
virtual ~A()=0; // 纯虚析构函数
};
在继承下，为了使子类析构函数得到正常使用，需要降级类的析构函数设置为虚析构函数。考虑下面的例子：
class A{
public:
A() { ptra_ = new char[10];}
~A() { delete[] ptra_;} // 非虚析构函数
private:
char * ptra_;
};
class B: public A{
public:
B() { ptrb_ = new char[20];}
~B() { delete[] ptrb_;}
private:
char * ptrb_;
};
void foo(){
A *a = new B;
delete a;
}
在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！这样会造成内存泄露。
如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。
纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。
