C++ 继承与多态(四)：重载(overload)、覆盖(override)、隐藏(overhide)之间的关系

C++ 继承与多态(四)：重载(overload)、覆盖(override)、隐藏(overhide)之间的关系

---

一. 重载(overload)：

限定范围：同一个类中
函数名相同，但是参数个数，或者参数类型不同则为重载。
注意：返回值类型不同并不属于重载！

class A{
public:
    virtual void func();
    //int func();//ERROR!overload can't be distinguished by return type;
    int func(int);
    int func(double);
};

二.隐藏(oversee)

限定范围：派生类
派生类的函数与基类的函数名相同，那么派生类的函数将会吧基类的函数隐藏起来，如果想使用基类中的函数，则需要使用域限定符::

class Base{
public:
    void func(){
        cout << "Base::func()" << endl;
    }

    virtual void func2(){
        cout << "Base::func2()" << endl;
    }
};

class Derived:public Base{
public:
    //oversee 隐藏
    void func(){
        cout << "Derived::func()" << endl;
    }

    //overload 重载 ，注意，如果没有上面的func，这个func应该属于隐藏，因为两个函数不在一个类中
    void func(int a){
        cout << "Derived:func(int)" << endl;
    }

    //隐藏
    void func2(int a){
        cout << "Derived::func2(int)" << endl;
    }
};

void test2(){
    Derived b;
    b.func();
    b.Base::func();//oversee, 被隐藏了
    b.func(1);
}

三.覆盖(override):

限定范围：有虚函数的派生类中
派生类中的函数与基类中的虚函数完全相同
注：完全相同的意思是函数名，形参，返回值完全相同

为什么要叫覆盖？
因为C继承了虚函数表之后，在虚函数表中func将原来的B中的func地址进行了覆盖，也就是更新了虚函数表

class B{
public:
    virtual void func(){
        cout << "B::func()" << endl;
    }
};


class C:public B{
public:
    //虚函数
    void func(){
        cout << "C::func()" << endl;
    }

    //这完全是一个新的函数，也不是虚函数，由于不是虚函数，不能实现动态联编
    void func(int a){
        cout << "C::func(int a)" << endl;
    }

};

void test3(){
    B* b = new C();
    b->B::func();//这个操作并没有查虚函数表，而是直接调用该函数
    b->func();
}

int main(){
    test3();
    return 0;
}

四.一个复杂继承的类判断这三种关系

区分在使用多态的过程中，什么时候是动态联编，什么时候是动态联编
在使用多态的过程中，C继承了A，B的虚函数表并进行覆盖，

多态的过程可以这样理解：new出C的对象，然后再按照A的规格，进行转换（这个时候虚函数表已经完成了覆盖，然后再向A类适配转换）

A* pa = new C(); 可以理解成 在类A中操作已经覆盖了的虚函数表，同时也有可能进行静态联编
B* pb = new C(); 可以理解成 在类B中操作已经覆盖了的虚函数表，同时也有可能进行静态联编

class A
{
public:
    virtual void a() //虚函数
    {
        cout << "a() in A" << endl;
    }
    virtual void b() //虚函数
    {
        cout << "b() in A" << endl;
    }
    virtual void c() //虚函数
    {
        cout << "c() in A" << endl;
    }
};

class B
{
public:
    virtual void a() //虚函数
    {
        cout << "a() in B" << endl;
    }
    virtual void b() //虚函数
    {
        cout << "b() in B" << endl;
    }
    void c() //非虚函数
    {
        cout << "c() in B" << endl;
    }
    void d() //非虚函数
    {
        cout << "d() in B" << endl;
    }
};

class C : public A, public B
{
public:
    virtual void a() //虚函数，覆盖
    {
        cout << "a() in C" << endl;
    }
    void c() 
    {
        cout << "c() in C" << endl;
    }
    void d() //非虚函数，隐藏
    {
        cout << "d() in C" << endl;
    }
};

void test1()
{
    C c;
    A *pa = &c;
    pa->a();
    pa->b();
    pa->c();
    //pa->d();//ERROR! 从A继承下来的虚函数表中没有覆盖d
}

void test2(){
    C c;
    B *pb = &c;
    pb->a();
    pb->b();
    pb->c();//这里实现的是静态联编，也就是直接在类B中寻找，与多态无关
    pb->d();//同上
}

void test3(){
    C c;
    C* pc = &c;
    pc->a();

    //pc->b();//ERROR!编译器并不知道是哪一张虚函数表中的b()
    pc->A::b();
    pc->B::b();

    pc->c();
    pc->A::c();
    pc->B::c();
    
    pc->d();
    pc->B::d();
}

int main()
{
    test3();
    return 0;
}