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

创新互联建站是专业的嵩明网站建设公司，嵩明接单;提供做网站、成都做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行嵩明网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

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
using namespace std;
class A
{
public:
virtual void test(int i)
{
cout<<”This is A::test()”<}
};
class B:public A
{
public:
virtual void test(char s)
{
cout<<”This is B:test()”<}
};
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
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
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) : 3
B::test2(int) : 10
B::test2(int) : 20

新闻名称：类成员函数的重载、覆盖和隐藏区别？
URL地址：http://myzitong.com/article/jocjgc.html