C++ 重载、覆盖和隐藏

一、概念：

1、重载（overload）
指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。
（1）相同的范围（在同一个作用域中） ；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
（5）返回值可以不同；

2、覆盖（也称为重写 override）
是指派生类重新定义基类的虚函数，特征是：
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有 virtual 关键字，不能有 static 。
（5）返回值相同。
（6）重写函数的访问修饰符可以不同。尽管 virtual 是 private 的，派生类中重写改写为 public,protected 也是可以的

3、隐藏（也成重定义）
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同，或者参数相同，但是基类函数没有 virtual关键字。

二、代码：

#include <iostream>

class Parent
{
public:
    Parent()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    virtual ~Parent()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    void f1()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    virtual void f2()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    void f3()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    virtual void f4() = 0;
};

class Child : public Parent
{
public:
    Child()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    virtual ~Child()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    // 隐藏：与基类成员函数名称相同，参数相同，但基类函数未声明 virtual
    void f1()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    // 隐藏：与基类成员函数名称相同，参数不同
    void f1(int a)
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    // 覆盖：与基类成员函数名称相同，参数相同，但基类函数声明 virtual
    // 一般情况下，覆盖的派生类成员函数声明为 virtual，在声明尾部增加 override
    void f2()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    // 纯虚函数方法实现
    virtual void f4()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

int main()
{
    const char* a = "123";// 字面常量，a和b相等
    const char* b = "123";
    int size1 = sizeof(Parent);
    int size2 = sizeof(Child);

    Parent* p = new Child();// Parent::Parent + Child::Child
    p->f1();    // Parent::f1
//    p->f1(1);    // 编译报错，原因 该方法隐藏
    p->f2();    // Child::f2   动态绑定
    p->f3();    // Parent::f3
    p->f4();

    Child* c = new Child();// Parent::Parent + Child::Child
    c->f1();    // Child::f1
    c->f1(1);    // Child::f1
    c->f2();    // Child::f2
    c->f3();    // Parent::f3  继承方法
    c->f4();

    delete p; // Child::Child + Parent::Parent
    delete c; // Child::Child + Parent::Parent
    return 0;
}