c++中的重载和重写和覆盖的区别

参考博客：C++中重载、重写（覆盖）和隐藏的区别 - 头文件1991 - 博客园

以下代码加入一些修改之后，区分函数的重写问题，已经建立对象来调用

#include<iostream>
using namespace std;


 class Base
 {
     public:
             virtual void fun(int i){ cout << "Base::fun(int) : " << i << endl; }
         };

 class Derived : public Base
 {
     public:
             virtual void fun(int i){ cout << "Derived::fun(int) : " << i << endl; }
         };

 int main()
 {
         //Base b;
         Base * pb = new Derived();
         pb->fun(3);//Derived::fun(int)
    
         Base *b = new Base();
         b->fun(6);

         Derived *a = new Derived();
         a->fun(8);

         system("pause");
         return 0;
     }

2022.5.9增加：

以上说明：（1）重写的基类必须有virtual来进行修饰，但是在重载函数中可以使用virtual来修饰，也可也不使用

（2）以上内容中的子类中并没有隐藏基类中的重写函数

（3）重写的子类中的函数：函数名相同、参数列表相同

2、参考博客：C++的重载（overload）与重写（override） - 杨铭宇 - 博客园

令人迷惑的隐藏规则

本来仅仅区别重载与重写并不算困难，但是C++的隐藏规则（遮蔽现象）使问题复杂性陡然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏。（重写函数，基类与派生类中）
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。（重写基类函数中若没有virtual，则基类函数被子类隐藏）
这种隐藏规则，不仅仅是表现在对成员函数上，对同名的data member也是如此。

以下程序是参考，修改之后的理解：

#include <iostream>
using namespace std;

    class Base
    {
    public:
        virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
        void g(float x){ cout << "Base::g(float) " << x << endl; }
        void h(float x){ cout << "Base::h(float) " << x << endl; }
    };

    class Derived : public Base
    {
    public:
        virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
        void g(int x){ cout << "Derived::g(int) " << x << endl; }
        void h(float x){ cout << "Derived::h(float) " << x << endl; }
    };

    int main(void)
    {
       // Derived d;
       // Base *pb = &d;
       //Derived *fd = &d; //1、通过创建对象，并通过对象指针的形式来调用
        
        Base *pb = new Derived();//2、通过直接new对象的形式.但是这种形式需要手动删除内存垃圾
        Derived *fd = new Derived();
        // Good : behavior depends solely on type of the object
        pb->f(3.14f); //Derived::f(float) 3.14，基类被重写
        fd->f(3.14f); //Derived::f(float) 3.14，基类被重写
    
        // Bad : behavior depends on type of the pointer
        pb->g(3.14f); //Base::g(float) 3.14
        fd->g(3.14f); //Derived::g(int) 3，基类被隐藏
    
        // Bad : behavior depends on type of the pointer
        pb->h(3.14f); //Base::h(float) 3.14
        fd->h(3.14f); //Derived::h(float) 3.14，基类被隐藏

        delete pb;//运用前面的new的形式创建对象，则这边需要进行手动删除
        delete fd;

        system("pause");
        return 0;
    }

参考博客：C++:重载，重定义，重写的区别__来信的博客-优快云博客_c++重载和重写的区别

重定义的函数 = 隐藏

参考代码，并加入一些整理得出：

#include <iostream>

using namespace std;

class A{
public:
    void f()
    {
        cout << "A" << endl;
    }

public:
    int _x;
};

class B : public A{
public:
    void f(int a)
    {
        cout << "B" << endl;
    }

public:
    int _x;
};
int main()
{
    B b;
    b.f(1);//这种就是子类将父类的名字隐藏了
    while (1);
    return 0;
}

以上中：基类函数没有virtual、并且基类中的函数参数列表不同，所以导致最后子类函数将基类函数进行隐藏

以下关于重写和覆盖： 

​

 第一种是：重写

第二种：覆盖，同名函数，谁调用，就用谁的

隐藏：

c++中的重载（同一类）覆盖（不同类）_zzmc的博客-优快云博客