一、多态的定义
派生类对象的地址可以赋值给基类指针。对于通过基类指针调用基类和派生类中都有的同名、同参数表的虚函数的语句，编译时并不确定要执行的是基类还是派生类的虚函数；而当程序运行到该语句时，如果基类指针指向的是一个基类对象，则基类的虚函数被调用，如果基类指针指向的是一个派生类对象，则派生类的虚函数被调用。这种机制就叫作“多态（polymorphism）”。多态可以简单地理解为同一条函数调用语句能调用不同的函数；或者说，对不同对象发送同一消息，使得不同对象有各自不同的行为。
所谓“虚函数”，就是在声明时前面加了 virtual 关键字的成员函数。virtual 关键字只在类定义中的成员函数声明处使用，不能在类外部写成员函数体时使用。静态成员函数不能是虚函数。包含虚函数的类称为“多态类”。
*例如以下程序：
#include <iostream>
using namespace std;
class A
{
public:
virtual void Print() { cout << "A::Print" << endl; }
};
class B : public A
{
public:
virtual void Print() { cout << "B::Print" << endl; }
};
class D : public A
{
public:
virtual void Print() { cout << "D::Print" << endl; }
};
class E : public B
{
virtual void Print() { cout << "E::Print" << endl; }
};
int main()
{
A a; B b; D d; E e;
A *pa = &a; B *pb = &b;
pa->Print(); //多态， a.Print()被调用，输出：A::Print
pa = pb; //基类指针pa指向派生类对象b
pa->Print(); //b.Print()被调用，输出：B::Print
pa = &d; //基类指针pa指向派生类对象d
pa->Print(); //多态， d. Print ()被调用,输出：D::Print
pa = &e; //基类指针pa指向派生类对象d
pa->Print(); //多态， e.Print () 被调用,输出：E::Print
return 0;
}
二、通过基类引用实现多态
- 通过基类的引用调用虚函数的语句也是多态的。即，通过基类的引用调用基类和派生类中同名、同参数表的虚函数时，若其引用的是一个基类的对象，则被调用是基类的虚函数；若其引用的是一个派生类的对象，则被调用的是派生类的虚函数。
#include <iostream>
using namespace std;
class A
{
public:
virtual void Print() { cout << "A::Print" << endl; }
};
class B : public A
{
public:
virtual void Print() { cout << "B::Print" << endl; }
};
void Printlnfo(A & r)
{
r.Print(); //多态，调用哪个Print，取决于r引用了哪个类的对象
}
int main()
{
A a; B b;
Printlnfo(a); //输出 A::Print
Printlnfo(b); //输出 B::Print
return 0;
}
第 15 条语句就是通过基类的引用调用基类和派生类中都有的同名、同参数表的虚函数，因而符合多态的规则。
第 20 行的执行过程中，Printlnfo 函数的形参 r 引用的是基类对象 a，因此调用 A::Print。
第 21 行的执行过程中，r 引用的是类 B 的对象 b，因此调用 B::Print。
第 15 行的函数调用语句每次执行时，调用的可能是不同类的 Print 成员函数，因此这条语句编译时不可能确定它到底调用的是哪个类的 Print 成员函数，即无法静态联编。
三、静态多态和动态多态
1.静态多态
#include<iostream>
using namespace std;
int Add(int left, int right)
{
return left + right;
}
double Add(double left, int right)
{
return left + right;
}
int main()
{
Add(10, 20);
//Add(10.0, 20.0); //这是一个问题代码
Add(10.0, 20); //正常代码
return 0;
}
可见，静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错
2.动态多态
动态多态是在程序运行时根据基类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。
#include<iostream>
using namespace std;
class TakeBus
{
public:
void TakeBusToSubway()
{
cout << "go to Subway--->please take bus of 318" << endl;
}
void TakeBusToStation()
{
cout << "go to Station--->pelase Take Bus of 306 or 915" << endl;
}
};
//知道了去哪要做什么车可不行，我们还得知道有没有这个车
class Bus
{
public:
virtual void TakeBusToSomewhere(TakeBus& tb) = 0; //？？？为什么要等于0
};
class Subway :public Bus
{
public:
virtual void TakeBusToSomewhere(TakeBus& tb)
{
tb.TakeBusToSubway();
}
};
class Station :public Bus
{
public:
virtual void TakeBusToSomewhere(TakeBus& tb)
{
tb.TakeBusToStation();
}
};
int main()
{
TakeBus tb;
Bus* b = NULL;
//假设有十辆公交车，如果是奇数就是去地铁口的，反之就是去火车站的
for (int i = 1; i <= 10; ++i)
{
if ((rand() % i) & 1)
b = new Subway;
else
b = new Station;
}
b->TakeBusToSomewhere(tb);
delete b;
return 0;
}每一个函数前都加了virtual这个虚拟关键字，如果不加会不会构成多态呢？
若不加cirtual，实验如下：
#include<iostream>
using namespace std;
class Base
{
public:
virtual void Funtest1(int i)
{
cout << "Base::Funtest1()" << endl;
}
void Funtest2(int i)
{
cout << "Base::Funtest2()" << endl;
}
};
class Drived :public Base
{
virtual void Funtest1(int i)
{
cout << "Drived::Fubtest1()" << endl;
}
void Funtest2(int i)
{
cout << "Drived::Fubtest2()" << endl;
}
};
void TestVirtual(Base& b)
{
b.Funtest1(1);
b.Funtest2(2);
}
int main()
{
Base b;
Drived d;
TestVirtual(b);
TestVirtual(d);
return 0;
}
在调用FuncTest2的时候我们看出来他并没有给我们调用派生类的函数
因此：
动态多态的条件：
基类中必须包含虚函数，并且派生类中一定要对基类中的虚函数进行重写。
*通过基类对象的指针或者引用调用虚函数。
重写 ：
（a）基类中将被重写的函数必须为虚函数（上面的检测用例已经证实过了）
（b）基类和派生类中虚函数的原型必须保持一致（返回值类型，函数名称以及参数列表），协变和析构函数（基类和派生类的析构函数是不一样的）除外
（c）访问限定符可以不同
四、多态的实现原理
一个接口，多种方法
五、多态的缺陷
降低了程序运行效率（多态需要去找虚表的地址）
空间浪费