多态

多态简单说就是多种形态。

多态可以分为静态多态和动态多态。静态多态是在编译期间完成的，编译器会根据函数实参的类型，可以推断出想要调用的那个函数，要是没有能够调用的函数，那么编译就会出错。比如：

#include<iostream>
using namespace std;
int ADD(int i, int j)
{
	return i + j;
}
double ADD(double i, double j)
{
	return i + j;
}
int main()
{
	cout << ADD(1, 2) << endl;
	cout << ADD(1.2, 1.3) << endl;
}

动态多态：在程序执行期间判断所引用对象的实际类型，根据其实际类型调用相应的方法。而动态绑定的条件是：1，必须是虚函数。2，通过基类类型的引用或者指针调用虚函数。

首先了解几个基本概念的区分：

重载：a）是在同在作用域

            b）函数名相同，参数不同

            c）返回值可以不同

重写：a）不在同一作用域（分别在基类和派生类）

             b）函数名相同，参数相同，返回值相同

             c）基类必须有virtual关键字

             d）访问修饰符可以不同

重定义：a）在不同的作用域中

                b）函数名相同

                d）在基类和派生类中只要不构成重写就是重定义

现在来看一个例子：

#include<iostream>
using namespace std;
class Base
{
public:
	virtual void Funtest1(int _iTest)
	{
		cout << "Base::Funtest1" << endl;
	}
	void Funtest2(int _itest)
	{
		cout << "Base::Funtest2" << endl;
	}
	virtual void Funtest3(int _iTest)
	{
		cout << "Base::Funtest3" << endl;
	}
	virtual void Funtest4(int _iTest)
	{
		cout << "Base::Funtest4" << endl;
	}
};
class Derived :public Base
{
	virtual void Funtest1(int _iTest)
	{
		cout << "Derived::Funtest1" << endl;
	}
	virtual void Funtest2(int _iTest)
	{
		cout << "Derived::Funtest2" << endl;
	}
    void Funtest3(int _iTest)
	{
		cout << "Derived::Funtest3" << endl;
	}
	virtual void Funtest4(int _iTest1 ,int _iTest2)
	{
		cout << "Derived::Funtest4" << endl;
	}
};
int main()
{
	Base* pBaes = new Derived;//如果构成重写就会调用派生类的对象
	pBaes->Funtest1(0);//因为构成重写的条件，所以调用派生类的函数
	pBaes->Funtest2(0);//调用基类
	pBaes->Funtest3(0);//调用派生类
	pBaes->Funtest4(0);//调用基类
	//pBaes->Funtest4(0,0);//不能通过编译，因为在基类中只有一个参数
	return 0;
}

如果在基类中是个虚函数，那么在派生类中写不写virtual都默认为是虚函数，例如，Funtset3。