C++ 中重载、重写与隐藏的区别详解

#include <iostream>
using namespace std;

class Calculator {
public:
    // 重载函数：参数个数不同
    int add(int a, int b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }

    // 重载函数：参数类型不同
    double add(double a, double b) {
        return a + b;
    }

    // 错误示例：仅返回类型不同，不是有效的重载
    // double add(int a, int b) { return (double)(a + b); } // 编译错误
};

int main() {
    Calculator calc;
    cout << "calc.add(1, 2) = " << calc.add(1, 2) << endl;       // 调用 int add(int, int)
    cout << "calc.add(1, 2, 3) = " << calc.add(1, 2, 3) << endl; // 调用 int add(int, int, int)
    cout << "calc.add(1.5, 2.5) = " << calc.add(1.5, 2.5) << endl; // 调用 double add(double, double)
    return 0;
}

#include <iostream>
using namespace std;

class Animal {
public:
    // 基类虚函数
    virtual void speak() {
        cout << "Animal makes a sound." << endl;
    }
    virtual ~Animal() {} // 虚析构函数，良好实践
};

class Dog : public Animal {
public:
    // 重写基类虚函数
    void speak() override { // C++11 使用 override 确保正确重写
        cout << "Dog barks: Woof! Woof!" << endl;
    }
};

class Cat : public Animal {
public:
    // 重写基类虚函数
    void speak() override {
        cout << "Cat meows: Meow~" << endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->speak(); // 输出: Dog barks: Woof! Woof!
    animal2->speak(); // 输出: Cat meows: Meow~

    delete animal1;
    delete animal2;
    return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    void func() {
        cout << "Base::func()" << endl;
    }
    void func(int x) { // 重载版本
        cout << "Base::func(int): " << x << endl;
    }
};

class Derived : public Base {
public:
    // 定义了同名函数，隐藏了基类中的所有 func 函数
    void func() {
        cout << "Derived::func()" << endl;
    }
    // 注意：这里并没有重载 Base::func(int)，而是隐藏了它。
};

int main() {
    Derived d;
    d.func();       // 正确：调用 Derived::func()
    // d.func(10);  // 错误！Base::func(int) 被隐藏了，无法直接调用。

    // 使用作用域解析运算符调用被隐藏的基类函数
    d.Base::func();      // 正确：调用 Base::func()
    d.Base::func(100);   // 正确：调用 Base::func(int)

    Base* ptr = &d;
    ptr->func();    // 正确：调用 Base::func() (非虚函数，静态绑定)
    ptr->func(200); // 正确：调用 Base::func(int)
    return 0;
}

class Base {
public:
    void show(int) { /* ... */ }
};
class Derived : public Base {
public:
    void show(double) { /* ... */ } // 隐藏了 Base::show(int)，并未重载
};
// Derived d; d.show(10); // 错误！需要类型转换，因为 Base::show(int) 被隐藏了。

class Derived : public Base {
public:
    using Base::show; // 引入 Base 中的所有 show 函数
    void show(double) { /* ... */ } // 现在与引入的 show(int) 形成重载
};
// Derived d; d.show(10); // 正确：调用 Base::show(int)