类成员函数中重载/重写(覆盖)/重定义(隐藏)的区别

转自http://blog.csdn.net/yanjun_1982/archive/2005/09/02/470405.aspx 

这三个概念都是与OO中的多态有关系的。如果单是区别重载与覆盖这两个概念是比较容易的，但是隐藏这一概念却使问题变得有点复杂了，下面说说它们的区别吧。

       重载是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。

       覆盖（也叫重写）是指在派生类中重新对基类中的虚函数（注意是虚函数）重新实现。即函数名和参数都一样，只是函数的实现体不一样。

       隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了。隐藏与另外两个概念表面上看来很像，很难区分，其实他们的关键区别就是在多态的实现上。什么叫多态？简单地说就是一个接口，多种实现吧。

       还是引用一下别人的代码来说明问题吧（引用自林锐的《高质量C/C++编程指南》）。

仔细看下面的代码： 

#include        class Base   {   public:       virtual void f(float x){ cout << "Base::f(float) " << x << endl; }   void g(float x){ cout << "Base::g(float) " << x << endl; }              void h(float x){ cout << "Base::h(float) " << x << endl; }   };

class Derived : public Base  {   public:       virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }   void g(int x){ cout << "Derived::g(int) " << x << endl; }              void h(float x){ cout << "Derived::h(float) " << x << endl; }  };

看出什么了吗？下面说明一下：

（1）函数Derived::f(float)覆盖了Base::f(float)。  

（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。  

（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。
  

       嗯，概念大概明白了，但是在实际的编程中，我们会因此遇到什么问题呢？再看下面的代码：

void main(void)  

{  

Derived  d;  

Base *pb = &d;  

Derived *pd = &d; 
 

// Good : behavior depends solely on type of the object  

pb->f(3.14f); // Derived::f(float) 3.14  

pd->f(3.14f); // Derived::f(float) 3.14  

// Bad : behavior depends on type of the pointer  

pb->g(3.14f); // Base::g(float) 3.14  

pd->g(3.14f); // Derived::g(int) 3        (surprise!)  

// Bad : behavior depends on type of the pointer  

pb->h(3.14f); // Base::h(float) 3.14      (surprise!)  

pd->h(3.14f); // Derived::h(float) 3.14  

} 

在第一种调用中，函数的行为取决于指针所指向的对象。在第二第三种调用中，函数的行为取决于指针的类型。所以说，隐藏破坏了面向对象编程中多态这一特性，会使得OOP人员产生混乱。  

不过隐藏也并不是一无是处，它可以帮助编程人员在编译时期找出一些错误的调用。但我觉得还是应该尽量使用隐藏这一些特性，该加virtual时就加吧。

c++ 重载 覆盖 隐藏的区别和执行方式

成员函数被重载的特征 （1）相同的范围（在同一个类中）；  （2）函数名字相同；  （3）参数不同；  （4）virtual 关键字可有可无。  覆盖是指派生类函数覆盖基类函数，特征是 （1）不同的范围（分别位于派生类与基类）；  （2）函数名字相同；  （3）参数相同；  （4）基类函数必须有virtual 关键字。  “隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下 （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。  （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆） “overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖,使原来的失去效果。 先来说说重载的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服的方式来洗一件衣服，但是谁也不会用洗衣服的方式来洗一辆车，否则等洗完时车早就散架了。我们并不要那么明确地指出来就心知肚明，这就有重载的意思了。在同一可访问区内被声名的几个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调用哪个函数，这种机制叫重载，重载不关心函数的返回值类型。这里，“重载”的“重”的意思不同于“轻重”的“重”，它是“重复”、“重叠”的意思。例如在同一可访问区内有： ① double calculate(double); ② double calculate(double，double); ③ double calculate(double, int); ④ double calculate(int, double); ⑤ double calculate(int); ⑥ float calculate(float); ⑦ float calculate(double); 六个同名函数calculate，①②③④⑤⑥中任两个均构成重载，⑥和⑦也能构成重载，而①和⑦却不能构成重载，因为①和⑦的参数相同。 覆盖是指派生类中存在重新定义的函数，其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致，覆盖函数和被覆盖函数只有函数体（花括号中的部分）不同，当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本，这种机制就叫做覆盖。 下面我们从成员函数的角度来讲述重载和覆盖的区别。 成员函数被重载的特征有： 1) 相同的范围（在同一个类中）； 2) 函数名字相同； 3) 参数不同； 4) virtual关键字可有可无。 覆盖的特征有： 1) 不同的范围（分别位于派生类与基类）； 2) 函数名字相同； 3) 参数相同； 4) 基类函数必须有virtual关键字。 比如，在下面的程序中： #include class Base { public: void f(int x){ cout << "Base::f(int) " << x << endl; } void f(float x){ cout << "Base::f(float) " << x << endl; } virtual void g(void){ cout << "Base::g(void)" << endl;} }; class Derived : public Base { public: virtual void g(void){ cout << "Derived::g(void)" << endl;} }; void main(void) { Derived d; Base *pb = &d; pb->f(42); // 运行结果: Base::f(int) 42 pb->f(3.14f); // 运行结果: Base::f(float) 3.14 pb->g(); // 运行结果: Derived::g(void) } 函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。 隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下： 1) 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。 2) 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。 比如，在下面的程序中： #include class Base { public: virtual void f(float x){ cout << "Base::f(float) " << x << endl; } void g(float x){ cout << "Base::g(float) " << x << endl; } void h(float x){ cout << "Base::h(float) " << x << endl; } }; class Derived : public Base { public: virtual void f(float x){ cout << "Derived::f(float) " << x << endl; } void g(int x){ cout << "Derived::g(int) " << x << endl; } void h(float x){ cout << "Derived::h(float) " << x << endl; } }; 通过分析可得： 1) 函数Derived::f(float)覆盖了Base::f(float)。 2) 函数Derived::g(int)隐藏了Base::g(float)，注意，不是重载。 3) 函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。 看完前面的示例，可能大家还没明白隐藏与覆盖到底有什么区别，因为我们前面都是讲的表面现象，怎样的实现方式，属于什么情况。下面我们就要分析覆盖与隐藏在应用中到底有什么不同之处。在下面的程序中bp和dp指向同一地址，按理说运行结果应该是相同的，可事实并非如此。 void main(void) { Derived d; Base *pb = &d; Derived *pd = &d; // Good : behavior depends solely on type of the object pb->f(3.14f); //运行结果: Derived::f(float) 3.14 pd->f(3.14f); //运行结果: Derived::f(float) 3.14 // Bad : behavior depends on type of the pointer pb->g(3.14f); //运行结果: Base::g(float) 3.14 pd->g(3.14f); //运行结果: Derived::g(int) 3 // Bad : behavior depends on type of the pointer pb->h(3.14f); //运行结果: Base::h(float) 3.14 pd->h(3.14f); //运行结果: Derived::h(float) 3.14 } 请大家注意，f()函数属于覆盖，而g()与h()属于隐藏。从上面的运行结果，我们可以注意到在覆盖中，用基类指针和派生类指针调用函数f()时，系统都是执行的派生类函数f()，而非基类的f()，这样实际上就是完成的“接口”功能。而在隐藏方式中，用基类指针和派生类指针调用函数f()时，系统会进行区分，基类指针调用时，系统执行基类的f()，而派生类指针调用时，系统“隐藏”了基类的f()，执行派生类的f()，这也就是“隐藏”的由来。 文章出处：DIY部落(http://www.diybl.com/course/3_program/c++/cppjs/20090302/156467.html)

3种情况怎么执行：

1。重载：看参数

2。隐藏：用什么就调用什么

3。覆盖：调用派生类

重载(overload)，覆盖(override),隐藏(hide)的区别  
http://www.cppblog.com/zgysx/archive/2007/03/12/19662.html 

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

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

　　实例一:
　　#include "stdafx.h"
　　#include

　　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

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

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