多态是面向对象编程的一个特性。它允许一个对象在不同的条件下表现出不同的结果。在c++中有两种多态的表现类型：
- 编译时多态(Compile time Polymorphism)。这个也被称为静态绑定(static binding)或者早期绑定(early binding)。
- 运行时多态(Runtime binding)。这个也被称为动态绑定(dynamic binding)或者迟绑定(late binding)。
<1>Compile time Polymorphism
方法的重载和操作符的重载都属于编译时多态的例子。接下来我们介绍下什么是方法重载。
方法重载（function overloading）
方法重载是c++编程的一个特性。它允许我们拥有多个方法名一样的方法，只需要这些方法的参数表是不一样的。所谓的参数表是指参数的数据类型和排列顺序。比如：
myFunc(int a, float b)的参数表是(int, float)。
myFunc(float a, int b)的参数表是(float, int)。
上面两个的方法名虽然都是myFunc，但是两个方法的参数表是不一样的。
总结：
判断是否符合重载条件只需要判断同名方法的参数是否满足参数的类型，数目， 顺序有存在不同。
注意：
如果参数表是一样的，即使方法的返回值不一样也是不合法的。只要参数列表是不同的，方法的返回值可以相同也可以不同。所以重载的条件就是需要参数列表的不同。判定不同的方法就是上面注意中提到的。
例如：
// 不合法
int sum(int, int)
double sum(int, int)
例子1
#include <iostream>
using namespace std;
class Addition {
public:
int sum(int num1,int num2) {
return num1+num2;
}
int sum(int num1,int num2, int num3) {
return num1+num2+num3;
}
};
int main(void) {
Addition obj;
cout<<obj.sum(20, 15)<<endl;
cout<<obj.sum(81, 100, 10);
return 0;
}
输出：
35
191
例子2
#include <iostream>
using namespace std;
class DemoClass {
public:
int demoFunction(int i) {
return i;
}
double demoFunction(double d) {
return d;
}
};
int main(void) {
DemoClass obj;
cout<<obj.demoFunction(100)<<endl;
cout<<obj.demoFunction(5005.516);
return 0;
}
输出：
100
5006.52
方法重载的优点
方法重载的主要是增加了代码的可读性和复用性（code readability and code reusability）。想象一下如果没有方法重载这种机制，我们可能要写很多不同的函数名但是操作的本质是一样的。这样代码的可读性就变得很差，而且也会在给函数起什么名字上面多耗精力。
方法重载的多态表现
从上面的例子中我们可以看到，方法重载是通过编译时通过不同的参数表来确定不同的版本的函数。调用时根据参数表的内容去找对应的版本的方式来实现多态的。
<2>Runtime Polymorphism
方法的重写就是运行时多态的例子。接下来我们介绍下什么是方法的重写。
方法的覆盖\重写（function overriding）
方法的覆盖也是c++编程的一种特性。这种机制允许我们在子类中拥有一个和父类一样的方法。子类可以继承了父类的数据成员和成员函数。当我们想要修改继承于父类的某种方法的功能时，我们就可以通过覆盖的机制来实现。通过这种方式，我们就好像在子类当中创建了一个父类对应该方法的新方法。
例子：
在重写一个方法时，我们需要保证子类中的方法签名和改写的父类方法一致。这里所指的方法签名是指参数的数据类型和顺序。下面这个例子中，要覆盖的父类方法中并没有任何参数，因此我们子类中的重写方法也不需要任何参数。
#include <iostream>
using namespace std;
class BaseClass {
public:
void disp(){
cout<<"Function of Parent Class";
}
};
class DerivedClass: public BaseClass{
public:
void disp() {
cout<<"Function of Child Class";
}
};
int main() {
DerivedClass obj = DerivedClass();
obj.disp();
return 0;
}
输出：
Function of Child Class
注意：
在方法重写中，在父类中对应的方法我们称之为被重写的方法（overridden function），在子类中的方法我们称之为重写方法（overriding function）。
如何通过子类调用被重写的父类方法
上面的例子我们看到了子类调用重写的方法。那么如何通过子类来调用父类中被重写的方法（overridden function）呢？我们可以通过用父类引用指向子类的实例的方式来调用我们的父类被重写的方法。用下面的例子来帮助我们理解：
#include <iostream>
using namespace std;
class BaseClass {
public:
void disp(){
cout<<"Function of Parent Class";
}
};
class DerivedClass: public BaseClass{
public:
void disp() {
cout<<"Function of Child Class";
}
};
int main() {
/* Reference of base class pointing to
* the object of child class.
*/
BaseClass obj = DerivedClass();
obj.disp();
return 0;
}
输出：
Function of Parent Class
如果你想要在子类中重写的函数（overriding function）中调用父类中被重写的函数（overridden function），你只需要这样做：
//父类类名::方法名
parent_class_name::function_name
如果用上面的例子来解释上面这种用法就是：
BaseClass::disp();
虚函数
当我们在父类中申明了一个函数为虚函数时，所有子类中该方法的重写函数都会默认的被认为是虚函数（不管是否有virtual关键字）。现在的问题是我们为什么要讲一个函数声明为虚函数呢？这是为了让编译器明白这个函数的调用必须到运行时间才能确定。只有当对象的类型被确定时，才知道调用哪个版本的函数。
接下来让我们来看两个例子来帮助理解。分别重写非虚函数的父类函数和重写虚函数的父类函数。
重写一个非虚函数
#include<iostream>
using namespace std;
//Parent class or super class or base class
class Animal{
public:
void animalSound(){
cout<<"This is a generic Function";
}
};
//child class or sub class or derived class
class Dog : public Animal{
public:
void animalSound(){
cout<<"Woof";
}
};
int main(){
Animal *obj;
obj = new Dog();
obj->animalSound();
return 0;
}
输出：
This is a generic Function
重写一个虚函数
#include<iostream>
using namespace std;
//Parent class or super class or base class
class Animal{
public:
virtual void animalSound(){
cout<<"This is a generic Function";
}
};
//child class or sub class or derived class
class Dog : public Animal{
public:
void animalSound(){
cout<<"Woof";
}
};
int main(){
Animal *obj;
obj = new Dog();
obj->animalSound();
return 0;
}
输出：
Woof
总结：
很显然，重写虚函数的方式使得调用的时候，程序是看对象的类型来决定调用的函数。在第二个覆盖虚函数的例子中，我们可以看见虽然obj指针的指针类型是父类Animal，但是其指向的对象是子类Dog的对象。因此这时候，调用的animalSound是子类中的重写函数而不是父类里头的该函数。接下来我们通过一个例子再来进一步了解下它的特性。
#include<iostream>
using namespace std;
class Base{
public:
Base(){
std::cout << "Base::Base()" << std::endl;
}
~Base(){
std::cout << "Base::~Base()" << std::endl;
}
void print1(){
std::cout << "Base::print1()" << std::endl;
}
void virtual print2(){
std::cout << "Base::print2()" << std::endl;
}
};
class Child:public Base{
public:
Child(){
std::cout << "Child::Child()" << std::endl;
}
~Child(){
std::cout << "Child::~Child()" << std::endl;
}
void print1(){
std::cout << "Child::print1()" << std::endl;
}
void print2(){
std::cout << "Child::print2()" << std::endl;
}
};
int main()
{
Base* base = new Base();
Child* child = new Child();
base->print1();
base->print2();
child->print1();
child->print2();
delete base;
delete child;
Child* child2 = nullptr;
child2->print1();
child2->print2();
return 0;
}
输出：
Base::Base()
Base::Base()
Child::Child()
Base::print1()
Base::print2()
Child::print1()
Child::print2()
Base::~Base()
Child::~Child()
Base::~Base()
Child::print1()
Thread 1: EXC_BAD_ACCESS (code=1, address=0x0)//报错
我们通过打印的信息能够更加清楚的了解到c++背后的运行机制。
- 首先我们创建了两个对象，分别是基类对象和子类对象，并分别用基类指针base和子类指针child指向它们。这个过程对应输出我们可以看出调用了构造函数。其中基类的构造函数被调用了两次。说明在创建子类对象的时候，调用了子类的构造函数，而子类的构造函数会先默认调用父类的构造函数，然后执行自己的构造函数。
- 通用基类和子类的指针分别调用print1和print2两个函数。这个地方没什么问题。基类指针指向基类对象，调用的必然是基类中的函数。子类也一样。
- 第三步删除对象。这边发现基类的析构函数也被调用了两次。和构造函数相同，子类在调用析构函数的时候，也会调用一次父类的析构函数。不过不同的是调用时期。析构的时候，是在执行完自己的析构函数体后再调用父类的析构。
- 最后一个涉及到多态的知识。首先创建了一个子类的指针child2并赋值为空指针nullptr。第一次调用print1，通过输出可以知道，该语句可以正常执行。并且调用的是子类的print1。说明了如果函数不是虚函数的情况下，c++是直接根据指针类型来判断调用的函数版本（到底是基类的，还是基类的版本）。第二句调用print2函数时报错。原因是print2是个虚函数（父类中声明了是虚函数，所有子类重写该函数都默认是虚函数）。通过虚函数的机制我们可以知道，要调用哪个版本（父类的版本还是子类的版本）需要在运行的时候通过指针所指向的对象类型来确定。此时，child2指针指向为空指针（没有指向任何实例对象），因此报错。
方法重载（function overloading）和方法重写（function overriding）的不同
到此我们已经理解了什么是c++编程中的方法重载和方法重写。让我们来看看它们的不同：
- 方法重载是在同一个类里头完成的。在同一个类中，我们声明方法名相同但是参数列表不一样的方法称为方法重载。
- 在方法重载时，我们必须确认函数的签名是不同的。但是在方法重写中，我们必须保证重写方法和被重写方法具有相同的签名。
- 方法重载发生在编译期间，因此也被成为编译时多态。而方法覆盖发生在运行期间，因此也被称为运行时多态。
- 方法重载时，在一个类中重载的方法数量没有限制。方法重写时，一个子类对应父类的某个方法只能被重写一次。
