C++：重载、覆盖和隐藏

重载、覆盖和隐藏

      共同点：函数名称相同。

（1）重载：必须在一个域内，函数名称相同但是函数参数不同。重载的作用就是同一个函数有不同的行为。

                     重载完全是一个编译时（或静态）的概念。如果声明了同名函数，编译器会在编译时处理这些同名函数的调用问题，

               确定调用哪一个函数，运行时不 涉及调用重载函数的额外开销或决定。而且，重载只用于函数，不用于类。

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

       分析：因为函数参数不同，可以简单的理解为：两个重载函数是不同的函数，调用者能够明确的根据不同的参数来调用不同的函数。

               那么如果存在这样两个函数，编译器怎么处理呢？

       例子：

              class A
                     {
                      public:
                      void Func(int a, int b=0) {printf("This is Func1/n");}
                      void Func(int a) {printf("This is Func2/n");}
                      };

              int main()
                     {
                         A a;
                         a.Func(5);
                         return 0;
                      }

               当然，对于这样两个函数，调用者不知道应该调用哪个函数，故编译器直接报错。

（2）覆盖：也称为重新定义（redefinition）。派生类希望覆盖所继承的行为，使得派生类的对象表现出自身的行为而非基类对象的行为。

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

                          关键字。

                         我们发现，这里用到了虚函数，实际上虚函数的作用，就是实现覆盖。

        分析：既然和虚函数挂钩，说明了这个是多态支持的特性(通过基类指针或引用间接指向派生类子类型时才有效)。

                只有在基类中声明为virtual的成员函数才能在派生类中被覆盖，不可能覆盖在基类中未声明为virtual的函数。但是，仅在基类

                的某函数前加virtual关键之，派生类不能据此将其解释为允许覆盖该函数，基类的设计者应该将可覆盖的函数声明为虚函数，

                并在文档中明确陈述派生类可覆盖该函数。总之一句话，覆盖函数都是虚函数，反之，不然。

                     覆盖是运行时的概念，它在运行时从一组被覆盖的函数中选择一个函数。只有动态绑定才能使用覆盖机制。通过覆盖，使

               用的是对象所实现的正确的方法，而不是调用接口所使用的方法。覆盖基于单个函数，派生类的方法覆盖在基类中声明的同名

               方法，覆盖只应用于类中的方法，不能应用于自由函数。覆盖意味着继承关系，没有继承，就不存在覆盖。

        例子：

                    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)覆盖。

（3）隐藏：指的是派生类的成员函数隐藏了基类函数的成员函数。隐藏的意思是，虽然现在看不到，但是并不表明不存在，只是暂时被隐

                藏起来了而已，所以，如果将一个子类的对象赋值给一个基类的指针，那么用该指针调用对应的成员函数时，调用的是被派生

                类隐藏了的对应的基类的成员函数。

        隐藏的规则：

               （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏。

                     （注意别与重载混淆）

               （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。

                    （注意别与覆盖混淆）

                分析：隐藏一词可以这么理解：在调用一个类的成员函数的时候，编译器会沿着类的继承链逐级的向上查找函数的定义，如果

                        找到了那么就停止查找了，所以如果一个派生类和一个基类都有同一个同名(暂且不论参数是否相同)的函数，而编译器

                        最终选择了在派生类中的函数，那么我们就说这个派生类的成员函数"隐藏"了基类的成员函数，也就是说它阻止了编译

                        器继续向上查找函数的定义。

          例子（1）：

 class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual 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; }
virtual void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
};

 在这个例子（1）中，（a）函数Derived::f(float)覆盖了Base::f(float)。
（b）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（c）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

      总结：重载与隐藏：相同点：（1）函数名相同（2）参数都不同（3）virtual关键字可有可无。

                                                  重载的函数，virtual关键字可有可无。

                                     不同点：（1）范围不同。重载的函数在同一个范围内（同一个类），隐藏的函数在基类和派生类。

                    覆盖与隐藏：相同点：（1）范围相同：函数在基类和派生类（2）函数名相同（3）参数相同

                                     不同点：（1）virtual关键字。基类如果没有virtual关键字，则被隐藏。而覆盖，基类必须有virtual关键字。

                                                        即，覆盖的函数是多态的，是存在于vtbl之中的函数才能构成“覆盖”关系，而隐藏的函数

                                                        都是一般的函数，不支持多态，在编译阶段就已经确定下来了。

            例子（2）：

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 (surprise!)
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 (surprise!)
pd->h(3.14f); // Derived::h(float) 3.14
}

         在例子（2）中，令人非常不解，bp和dp指向同一地址，按理说运行结果应该是相同的，可事实并非这样。所以我们还是要

    想办法摆脱隐藏。

               分析：出现surprise!的地方，还是和函数的动、静态绑定有关系。f函数是虚函数，但是h函数不是。声明为虚函数的类里面，

                       都包含一个vptr指针和一个所谓的虚函数表（vtbl）。在程序编译的时候，函数指针(指向函数的指针变量)f、g、h就已

                       经是确定的了，但是vptr指针根据不同的偏移量而不同，且这个变化是在运行期动态决定的。也就是说，函数的地址不

                       可变，但是vptr可变。代码Base *pb = &d;只是用Derived类对象d的vptr修改了Base类pb的vptr指针，但是当Base

                       类成员建立的时候，f,g,h函数指针是不能改变的。

                            当函数声明为virtual的时候，就激活了多态机制，程序在运行的时候会根据类型的实际类型到vtbl中查找函数指针，

                       去调用正确的函数来执行。h函数指针的类型在编译的时候已经确认了，所以在程序运行的时候不能发生改变，从而发生

                       了在子类中的“隐藏”现象。

              注意：还有一点要切忌，对于static这种静态成员函数，是属于类的方法，而不是对象的方法，

                      所以static方法绝对不能被覆盖或者隐藏。