C++ 重载、隐藏、覆盖的区别小结

class Base  
{
public:
    Base(int a):ma(a) {}
    // 重载1：无参 show
    virtual void show() {cout<<"Base::show()"<<endl;}
    // 重载2：带int参数的 show —— 与上面构成重载
    virtual void show(int i) {cout<<"Base::show(int)"<<endl;}
private:
    int ma;
};

int main() {
    Base b(10);
    b.show();    // 调用 Base::show() —— 匹配无参版本
    b.show(5);   // 调用 Base::show(int) —— 匹配int参数版本
    return 0;
}

class Derive : public Base
{
public:
    Derive(int a, int b):Base(a), mb(b) {}
    // 覆盖：与 Base::show() 签名完全一致，且父类是虚函数
    void show() override {cout<<"Derive::show()"<<endl;} // 加override更规范
private:
    int mb;
};

int main() {
    Base* ptr = new Derive(1, 2); // 父类指针指向子类对象
    ptr->show();  // 调用 Derive::show() —— 运行时动态绑定（多态）
    delete ptr;
    return 0;
}

int main() {
    Derive d(1, 2);
    d.show();    // 正常：调用 Derive::show()
    // d.show(5); // 编译错误！父类的 show(int) 被隐藏了
    return 0;
}

class Derive : public Base
{
public:
    Derive(int a, int b):Base(a), mb(b) {}
    // 子类定义 show(double) —— 与父类 show(int) 不同参，但依然隐藏父类所有 show
    void show(double d) {cout<<"Derive::show(double)"<<endl;}
private:
    int mb;
};

int main() {
    Derive d(1,2);
    // d.show(5); // 编译错误！父类 show(int) 被隐藏，子类只有 show(double)
    d.show(5.0); // 正常：调用 Derive::show(double)
    return 0;
}

class Derive : public Base
{
public:
    using Base::show; // 解除父类所有 show 函数的隐藏
    Derive(int a, int b):Base(a), mb(b) {}
    void show() override {cout<<"Derive::show()"<<endl;}
private:
    int mb;
};

// 此时调用正常
int main() {
    Derive d(1,2);
    d.show();    // 调用 Derive::show()
    d.show(5);   // 调用 Base::show(int) —— 隐藏被解除
    return 0;
}

int main() {
    Derive d(1,2);
    d.Base::show(5); // 直接调用父类的 show(int)，不受隐藏影响
    return 0;
}

#include <iostream>
using namespace std;

class Base  
{
public:
    Base(int a):ma(a) {}
    // 重载1：无参虚函数
    virtual void show() {cout<<"Base::show()"<<endl;}
    // 重载2：带int参数的虚函数（与上面构成重载）
    virtual void show(int i) {cout<<"Base::show(int) "<<i<<endl;}
private:
    int ma;
};

class Derive : public Base
{
public:
    using Base::show; // 解除父类show的隐藏（注释掉这行看隐藏效果）
    Derive(int a, int b):Base(a), mb(b) {}
    // 覆盖：重写父类无参show
    void show() override {cout<<"Derive::show()"<<endl;}
    // 新增：子类独有的show(double)（会隐藏父类show，除非加using）
    void show(double d) {cout<<"Derive::show(double) "<<d<<endl;}
private:
    int mb;
};

int main() {
    // 1. 测试Base的重载
    Base b(10);
    b.show();     // Base::show()
    b.show(5);    // Base::show(int) 5

    // 2. 测试多态（覆盖）
    Base* ptr = new Derive(1, 2);
    ptr->show();  // Derive::show() —— 动态绑定
    ptr->show(6); // Base::show(int) 6 —— 子类未覆盖该版本，调用父类
    delete ptr;

    // 3. 测试子类的隐藏与解除
    Derive d(1, 2);
    d.show();     // Derive::show()
    d.show(7);    // Base::show(int) 7（加using后生效，否则编译错误）
    d.show(3.14); // Derive::show(double) 3.14
    d.Base::show(); // 显式调用父类show()

    return 0;
}

#include <iostream>
using namespace std;

class Base  // Base base(10);
{
public:
    Base(int a):ma(a) {}
    // 虚函数
    virtual void show() {cout<<"Base::show()"<<endl;}
    virtual void show(int i) {cout<<"Base::show(int)"<<endl;}
private:
    int ma;
};

class Derive : public Base
{
public:
    Derive(int a, int b):Base(a), mb(b) {}
    void show() {cout<<"Derive::show"<<endl;}
private:
    int mb;
};