C++中重载与重写与隐藏

• 重载

       同一类中，函数重载，静态多态性；

      被声明的几个具有不同参数列（参数的类型，个数，顺序不同）的同名函数；

       重载不关心函数返回类型；

       根据参数列表确定调用哪个函数。

• 重写（覆盖） 

       与继承的概念有关，虚函数，动态多态性：指派生类中重新定义的函数。

       其函数名，参数列表，返回值类型，所有都必须同基类中被重写的函数一致；

       只有函数体不同（花括号内）；

       重写的基类中被重写的函数必须有virtual修饰；

       基类指针指向基类对象，调用基类函数；

       基类指针指向派生类对象，调用派生类成员函数；

• 隐藏（同名覆盖）

       是指派生类的函数屏蔽了与其同名的基类函数，注意只要同名函数;

       不管参数列表是否相同，基类函数都会被隐藏；

       派生类对象访问该函数时，基类函数都会被隐藏；

       基类指针指向基类对象，调用基类函数；

       基类指针指向派生类对象，还是调用基类成员函数；

#include <iostream>

using namespace std;

class Base
{
public:
    virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
    void g(float x){ cout << "Base::g(float) " << x << endl; }
    virtual void h(int 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)，而不是覆盖。

class B
{
public:
    void f(int) const
    {
        cout << "B.int" << endl;
    }
    void f(double) const
    {
        cout << "B.double" << endl;
    }
};


class D: public B
{
public:
    void f(void*) const
    {
        cout << "D.void" << endl;
    }
};
int main()
{
    D d;
    d.f(0);     //调用那个函数？
    d.f(1);     //调用那个函数？
    d.f(0.1);   //调用那个函数？
}

答案：3个调用全部调用子类的f(void*)。但由于后两个不能转换为void*，编译出错。void*是可以指向任何类型的指针。C++中，只有int 0可以转换为指针型，其余均不可以，所以出错。可以通过d.B::f()访问。