写正题之前，先给出几个关键字的中英文对照，重载(overload)，覆盖(override),隐藏(hide)。在早期的C++书籍中，可能 翻译的人不熟悉专业用语（也不能怪他们，他们不是搞计算机编程的，他们是英语专业的），常常把重载(overload)和覆盖(override)搞错！

　　我们先来看一些代码及其编译结果。

　　实例一：
　　
　　#include "stdafx.h"
　　#include <iostream.h>

　　class CB
　　{
　　public:
 　　　　void f(int)
 　　　　{
 　　　　　　 cout << "CB::f(int)" << endl;
　　　　 }

　　};

　　class CD : public CB
　　{
　　public:
　　　　 void f(int,int)
 　　　　{
  　　　　　　cout << "CD::f(int,int)" << endl;
 　　　　}

　　　　void test()
 　　　　{
  　　　　　f(1);
 　　　　}
　　};

　int main(int argc, char* argv[])
　{
　　　 return 0;
　}
编译了一下
error C2660: 'f' : function does not take 1 parameters

结论：在类CD这个域中，没有f(int)这样的函数，基类中的void f(int)被隐藏

　　如果把派生CD中成员函数void f(int,int)的声明改成和基类中一样，即f(int)，基类中的void f(int)还是一样被覆盖，此时编译不会出错，在函数中test调用的是CD中的f(int)　

　　所以，在基类中的某些函数，如果没有virtral关键字，函数名是f(参数是什么我们不管)，那么如果在派生类CD中也声明了某个f成员函数，那么在类CD域中，基类中所有的那些f都被隐藏。
　　如果你比较心急，想知道什么是隐藏，看文章最后的简单说明，不过我建议你还是一步一步看下去。

　　我们刚才说的是没有virtual的情况，如果有virtual的情况呢？？
　　实例二：

#include "stdafx.h"
#include <iostream.h>

class CB
{
public:
 　　virtual void f(int)
 　　{
  　　　　cout << "CB::f(int)" << endl;
 　　}

};

class CD : public CB
{
public:
　　 void f(int)
 　　{
  　　　　cout << "CD::f(int)" << endl;
　　 }

};

int main(int argc, char* argv[])
{
 　return 0;
}

　　这么写当然是没问题了，在这里我不多费口舌了，这是很简单的，多态，虚函数，然后什么指向基类的指针指向派生类对象阿，通过引用调用虚函数阿什么的，属性多的很咯，什么？？你不明白？？随便找本C++的书，对会讲多态和虚函数机制的哦！！
　　这种情况我们叫覆盖(override)！覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数！
　　在这里，我要强调的是，这种覆盖，要满足两个条件
　(a)有virtual关键字，在基类中函数声明的时候加上就可以了
　(b)基类CB中的函数和派生类CD中的函数要一模一样，什么叫一模一样，函数名，参数，返回类型三个条件。
　　有人可能会对(b)中的说法质疑，说返回类型也要一样？？
　　是，覆盖的话必须一样，我试了试，如果在基类中,把f的声明改成virtual int f(int)，编译出错了
　　error C2555: 'CD::f' : overriding virtual function differs from 'CB::f' only by return type or calling convention
　　所以，覆盖的话，必须要满足上述的(a)(b)条件

　　那么如果基类CB中的函数f有关键字virtual　，但是参数和派生类CD中的函数f参数不一样呢，
实例三:
  #include "stdafx.h"
#include <iostream.h>

class CB
{
　public:
 　　 virtual  void f(int)
　　 {
 　　　　 cout << "CB::f(int)" << endl;
　　 }

}
;

class CD : public CB
{
public:
 　　 void f(int，int)
 　　{
 　　　 cout << "CD::f(int，int)" << endl;
 　　}

　　void test()
 　　{
 　　　　 f(1);
 　　}
}
;

int main(int argc, char* argv[])
{
 return 0;
}

编译出错了，
 error C2660: 'f' : function does not take 1 parameters
　　咦？？好面熟的错？？对，和实例一中的情况一样哦，结论也是基类中的函数被隐藏了。

　　通过上面三个例子，得出一个简单的结论
如果基类中的函数和派生类中的两个名字一样的函数f
满足下面的两个条件
(a)在基类中函数声明的时候有virtual关键字
(b)基类CB中的函数和派生类CD中的函数一模一样，函数名，参数，返回类型都一样。
那么这就是叫做覆盖(override)，这也就是虚函数，多态的性质

那么其他的情况呢？？只要名字一样，不满足上面覆盖的条件，就是隐藏了。

下面我要讲最关键的地方了，好多人认为，基类CB中的f(int)会继承下来和CD中的f(int,int)在派生类CD中构成重载，就像实例一中想像的那样。
　　对吗？我们先看重载的定义
　　重载(overload):
　　必须在一个域中,函数名称相同但是函数参数不同,重载的作用就是同一个函数有不同的行为,因此不是在一个域中的函数是无法构成重载的,这个是重载的重要特征
　　必须在一个域中，而继承明显是在两个类中了哦，所以上面的想法是不成立的，我们测试的结构也是这样，派生类中的f(int,int)把基类中的f(int)隐藏了
　　所以，相同的函数名的函数，在基类和派生类中的关系只能是覆盖或者隐藏。

　　在文章中，我把重载和覆盖的定义都给了出来了，但是一直没有给隐藏的定义，在最后，我把他给出来，这段话是网上google来的，比较长，你可以简单的理解成，在派生类域中，看不到基类中的那个同名函数了，或者说，是并没有继承下来给你用，呵呵，如实例一　那样。
　　

隐藏(hide):
指的是派生类的成员函数隐藏了基类函数的成员函数.隐藏一 词可以这么理解:在调用一个类的成员函数的时候,编译器会沿着类的继承链逐级的向上查找函数的定义,如果找到了那么就停止查找了,所以如果一个派生类和一 个基类都有同一个同名(暂且不论参数是否相同)的函数,而编译器最终选择了在派生类中的函数,那么我们就说这个派生类的成员函数"隐藏"了基类的成员函 数,也就是说它阻止了编译器继续向上查找函数的定义

---------------------------------------------------------------------------------------------

如果基类声明了一个成员函数f(int)，并且派生类声明了一个成员函数f(float)（名称相同，但参数类型或数量不同），那么Base的 f(int)被隐藏（hidden）而不是被重载（overloaded）或被重写（overridden）（即使基类的f(int)是虚的）    
 
以下是你如何摆脱困境：派生类必须有一个被隐藏成员函数的using声明，例如：    
 
class  Base{  
public:  
voidf(int);  
};  
 
classDerived:publicBase{  
public:  
usingBase::f;//Thisun-hidesBase::f(int)  
voidf(double);  
};    
 
如果你的编译器不支持using语法，那么就重新定义基类的被隐藏的成员函数，即使它们是非虚的。一般来说这种重定义只不过使用::语法调用了基类被隐藏的成员函数，如，    
 
classDerived:publicBase{  
public:  
voidf(double);  
voidf(inti){Base::f(i);}//TheredefinitionmerelycallsBase::f(int)  
};    
 
 
以下是俺的程序：  
 
class  Parent  
{  
public:  
           virtual  void  foo()  
           {  
                       cout  <<  "foo  from  Parent"  <<  endl;;      
           }  
           void  foo1()  
           {  
                       cout  <<  "foo1  from  Parent"  <<  endl;;  
           }  
           virtual  void  foo2()  
           {  
                       cout  <<  "foo2  from  Parent"  <<  endl;;  
           }  
};  
 
class  Son  :  public  Parent  
{  
public:  
           void  foo()  
           {  
                       cout  <<  "foo  from  Son"  <<  endl;;      
           }  
           void  foo1()  
           {  
                       cout  <<  "foo1  from  Son"  <<  endl;;  
           }  
           void  foo2(int  i)  
           {  
                       cout  <<  "foo2  from  Son"  <<  endl;;  
           }  
};  
 
int  _tmain(int  argc,  _TCHAR*  argv[])  
{  
           Parent  *p  =  new  Son();  
           p->foo();  
           p->foo1();  
           p->foo2();  
 
           delete  p;  
           system("pause");  
           return  0;  
}  
 
如果按照"隐藏"的说法，foo2()被隐藏的话，那么应该编译不过才对。然而VC的输出是  
 
foo  from  Son  
foo1  from  Parent  
foo2  from  Parent  
 
那么，隐藏的机制到底是不是标准C++？我的做法可以被看作overload吗？  
隐藏是否只在foo1()中生效。即，隐藏也要看参数和类型完全一致，且父类的不能是虚函数？  
 
 ---------------------------------------------------------------  
 
int  main()  
{  
           Parent  *p  =  new  Son();  
           p->foo();                  //覆盖  一、（1）  
           p->foo1();                //隐藏  二、（2）  
           p->foo2();                //隐藏  二、（1）  
           delete  p;  
//            system("pause");  
           return  0;  
}  
一、覆盖是指派生类函数覆盖基类函数，特征是：  
（1）不同的范围（分别位于派生类与基类）；  
（2）函数名字相同；  
（3）参数相同；  
（4）基类函数必须有virtual关键字。  
二、"隐藏"是指派生类的函数屏蔽了与其同名的基类函数，规则如下：  
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。  
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。  
---------------------------------------------------------------  
 
其实这样来理解就比较容易搞懂了：  
1.虚函数的使用有特殊性，在使用的时候会查询指针所指对象内的虚函数表来确定具体应该调用的函数地址。因此调用虚函数的时候优先使用指针所指对象的类函数，而不是其基类的类函数，如果找不到则才从其基类中找一个匹配的成员函数  
比如:  
p->foo();//因为p指向的是派生类Son的对象，因此优先使用Son的成员函数foo()  
p->foo2();//Son类从不存在foo2()，但是从其基类中可以找到。因为没有重载，虚函数表中保存的是基类的成员函数foo2的指针。  
2.非虚成员函数的调用则是直接调用指针所指类对象的成员函数，而不会动态编译。  
比如：  
p->foo1();//编译器直接找到Parent类型的成员函数进行静态编译。  
 
---------------------------------------------------------------  
 
隐藏的几个特征：  
１　在基类和派生类之间  
２　函数名字相同  
如果参数类型不同的时候，有无virtual　关键字都为隐藏  
如果参数类型相同，则，无virtual　关键字时为隐藏  
顺便说说函数的重载与覆盖：  
重载：  
１　在同一个类里面  
２　函数名字相同  
３　函数参数不同  
４　virtual　关键字有无均可  
 
覆盖：  
１　在基类和派生类之间  
２　函数名字相同  
３　参数类型相同  
４　有virtual关键字  
 
上面是从　高质量C++编程指南看到的．  
---------------------------------------------------------------  
 
覆盖  主要用于从基类访问派生类  
而  隐藏  不行，只是隐藏掉了基类的函数，基类变量访问的只能是基类的那个函数  
重载  只是在同一个类里面  
 
---------------------------------------------------------------  
自己试了n多次，才基本明白这个意思...重载(overload)只在同一个类里生效。  
 
foo()是经典的override，而foo1()和foo2()全是hide，也即，foo1()和foo2()在子类中不可见。这里要注意，大家通常不会把foo1()认错，而对foo2()也是hide的行为通常不敏感。  
 
只 要子类中有一个同名的方法，不管他的参数列表是不是对得上，也不管父类的方法是不是virtual的（实际上，在这个case中不考虑virtual反而 不容易胡涂...记得只要没有override，虚表调用和非虚调用的结果并无区别。这一点jixingzhong兄要注意了），在子类中就不可能再看到 父类中的所有同名方法。  
 
然而，为什么我的返回不出错呢？因为我用的是..  父  类  的  指  针。  
foo()调用->典型的多态，动态连接到子类的虚表foo