1 重载

定义： C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。
注意：
返回值类型必须相同，否则报错，如下

1.cpp:10:11: error: ‘int printData::print(int)’ cannot be overloaded
       int print(int i) {
           ^
1.cpp:7:12: error: with ‘void printData::print(int)’
       void print(int i) {

代码

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
/* 返回类型不同出错
      int print(int i) {
        cout << "整数为: " << i << endl;
      }
*/
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}

2 重写（override）

子类重新定义父类中的虚函数，子类的函数可以被override修饰。

父类被重写的函数不能是static的，必须是virtual的（即在最原始的基类中被声明为virtual）

重写的函数必须有相同的名称，相同的参数列表。

重写根据实例的类型来调用相应的方法。

3重定义（redefine）

子类重新定义父类中的非虚函数，子类的函数不可以被override修饰。

重定义的函数必须具有相同的名称，参数列表可以不同。

重定义根据指针的类型来调用相应的方法。

代码

#include <iostream>
using namespace std;
class A {
public:
    virtual void foo() { // virtual  进行了修饰
        std::cout << "A::foo" << std::endl;
    }
    void bar() {
        std::cout << "A::bar" << std::endl;
    }
};

class B: public A {
public:
    void foo() override { // 重写，针对基类的虚函数
        std::cout << "B::foo:" << std::endl;
    }

    void bar(int a) { // 1 重定义，针对基类的同名函数，此处不能加 override 关键字
                      // 2 参数列表不同
        std::cout << "B::bar:"<< a << std::endl;
    }
};

int main()
{
    B* b = new B();
    A* a = new A();
    A* t = nullptr;
    B* p = nullptr;

    t = a;
    t->foo(); // 输出 A::foo
    t->bar(); // 输出 A::bar
    t = b;
    t->foo(); // 输出 B::foo
    t->bar(); // 输出 A::bar
    p = b;
    p->A::bar(); // 输出 A::bar
    p->bar(1); // 输出 B::bar

    delete a;
    delete b;
}