1.重载是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。实现原理上：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

特征：（1）相同的范围（在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。

class A{

public:void fun(int i);void fun(double i);void fun(int i, double j);void fun(double i, int j);int fun(int i); //错误，非重载};前四个为重载函数，最后一个不是

2.覆盖（重写）是指派生类函数覆盖基类函数(是指子类重新定义父类虚函数的方法。)。 实现原理：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

特征：（1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相同；（4）基类函数必须有virtual 关键字。

#include<iostream>

using namespace std;class A{ public:virtual void test(int i){ cout<<”This is A::test()”<<i<<endl;}};class B:public A{ public:virtual void test(char s){ cout<<”This is B:test()”<<s<<endl;}};int main(){ A a;B b;A * p=&a;p->test(3);p=&b;p->test(‘c’);return 0;}

3.隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

#include <iostream>

using namespace std;class A{ public:void foo(){ printf("1\n");}};class B :public A{ public:void foo(){ printf("3\n");}};int main(void){ A a;A *p_A = &a;p_A->foo();//执行成员函数

B b;B *p_B = &b;p_B->foo();//执行成员函数p_A = &b;   //p_A指针执行子类，可以访问被隐藏的基类成员函数p_A->foo();system("pause");return 0;

}

输出为1 3 1

隐藏和重写，重载的区别：

#include<iostream>using namespace std;class A{ public:void test1(int i, int j){ cout << "A::test1() : " << i << " " << j << endl;}void test1(int i){ cout << "A::test1() : " << i << endl; //重载}virtual void test2(int i){ cout << "A::test2(int) : " << i << endl;}};class B : public A{ public://隐藏void test1(double i){ cout << "B::test1() : " << i << endl;}//重写void test2(int i){ cout << "B::test2(int) : " << i << endl;}//隐藏void test2(double i){ cout << "B::test2(double) : " << i << endl;}};int main(){ B b;A pa = &b;

B pb = &b;pa->test2(3); //重写，多态性，调用B的函数b.test2(10); //隐藏，调用B的函数pb->test2(20); //隐藏，调用B的函数return 0;}

输出结果为：

B::test2(int) : 3B::test2(int) : 10B::test2(int) : 20