重载重写重定义

#include <iostream>
using namespace std;

class Base
{
public:
    // =========================================================================
    // 子类和父类返回值参数相同，函数名相同，有/无virtual关键字
    // =========================================================================

    // 若无virtual关键字，则在子类中声明与父类同名的方法，从而覆盖了父类的方法（函数重定义）
    void a()
    {
        cout << "Base::a()" << endl;
    };

    // 若有virtual关键字，即为虚函数。由对象的类型决定调用哪个函数（多态，函数重写override）。
    virtual void b()
    {
        cout << "Base::b()" << endl;
    }

    // =========================================================================
    // 子类和父类返回值参数不同，函数名相同，有/无virtual关键字
    // =========================================================================

    // 若无virtual关键字，父类的同名成员被隐藏。
    void d(int x)
    {
        cout << "Base::d() x = " << x << endl;
    }

    // 若有virtual关键字，父类的同名成员同样被隐藏。
    virtual void e(int x)
    {
        cout << "Base::e() x = " << x << endl;
    }

    // =========================================================================
    // 子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字
    // =========================================================================

    // 若无virtual关键字（函数重写，这种情况不属于“函数重载”范畴）
    void f()
    {
        cout << "void Base::f()" << endl;
    }

    // 若有virtual关键字 (报错）
    virtual void g()
    {
        cout << "virtual void Base::g()" << endl;
    }
};

class Derived : public Base
{
public:
    // =========================================================================
    // 子类和父类返回值参数相同，函数名相同，有/无virtual关键字
    // =========================================================================

    // 覆盖了父类同名方法（函数重写）
    void a()
    {
        cout << "Derived::a()" << endl;
    }

    // 多态
    virtual void b()
    {
        cout << "Derived::b()" << endl;
    }

    // =========================================================================
    // 子类和父类返回值参数不同，函数名相同，有/无virtual关键字
    // （注：函数重载与virtual关键字有无没有关系）
    // =========================================================================

    // 父类同名成员被隐藏
    void d(int x, int y)
    {
        cout << "Derived::d() x = " << x << " y = " << y<< endl;
    }

    // 父类同名成员被隐藏
    virtual void e(int x, int y)
    {
        cout << "Derived::e() x = " << x << " y = " << y << endl;
    }

    // =========================================================================
    // 子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字
    // =========================================================================

    // 返回值与基类不同
    int f()
    {
        cout << "int Derived::f()" << endl;
        return 1;
    }

     错误
    //virtual int g()
    //{
    // cout << "virtual int Base::g()" << endl;
    // return 1;
    //}
};

int main()
{
    // 用作参数
    int xx = 100;

    cout << "子类和父类返回值参数相同，函数名相同，无virtual关键字" << endl;
    Derived d;
    d.a();
    d.Base::a();    // 显示调用基类方法
    cout << "子类和父类返回值参数相同，函数名相同，有virtual关键字" << endl;
    Base* b = new Derived;  //多态
    b->b();
    Base* s = new Base;
    s->b();
    cout << "子类和父类返回值参数不同，函数名相同，无virtual关键字" << endl;
    d.d(xx, xx);
    // d.d(xx); // 报错
    d.Base::d(xx); // 显示调用
    cout << "子类和父类返回值参数不同，函数名相同，有virtual关键字" << endl;
    d.e(xx, xx);
    //d.e(xx); // 报错
    d.Base::e(xx);
    cout << "子类和父类返回值参数相同，函数名相同，函数返回值不同, 无virtual关键字" << endl;
    d.f();
    d.Base::f();
}