干！一文彻底搞懂C++重载、隐藏和覆盖（重写）！！！

最新推荐文章于 2024-08-30 08:30:00 发布
最新推荐文章于 2024-08-30 08:30:00 发布
阅读量1.9k 收藏 23
点赞数 10
分类专栏： C++基础 文章标签： c++ 多态 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43450920/article/details/119947807
版权

前言
之所以写这篇文章，一方面是想自己总结，彻底搞懂重载、隐藏和重写三者之间的关系，另一方面就是想帮助大家更清楚的认识这三者之间的关系。我在写这篇文章之前也大概搜索了一些关于这三者的博客，但是总感觉那些文章写的并不是我想要的，也并没有表达清楚这三者之间的关系，因此决定写下这篇博客。

我相信在看这篇文章之前肯定有很多小伙伴和我一样对这三者关系不是很清楚，总感觉是似懂非懂，总是差那么一点火候！有时候觉得自己懂了，可是换个时间，又感觉迷迷糊糊的，那么我相信你看了这篇文章后，这种感觉将不复存在！你将对重载、隐藏和重写有一个更深层次的认识！

我们一步一步来，同样，先看下这三者的定义，虽然说看完这个定义你还是迷迷糊糊。但是不急，温水煮青蛙，我们慢慢来，看到最后，拿下重载，隐藏和重写！

定义
重载：重载是C++继C而来特有的性质，相比于之前的C语言来讲，一个函数名只能出现一次。然而在C++中，函数名可以多次出现，但是想要发生重载必须要求函数名相同，参数列表不同（参数列表不同包括：参数个数不同，参数类型不同、参数出现的顺序不同）。
隐藏：隐藏，顾名思义就是被隐藏了导致我们看不到。那么隐藏的对象是什么？为什么会发生隐藏？隐藏只会发生在继承的关系中，当派生类（也叫子类）继承基类（也叫父类）时，如果派生类重新定义了基类中的同名函数，那么基类中重新定义的同名函数称作重写，未被重新定义的函数将被隐藏。
重写：重写也叫覆盖，是C++继承特性的另一种呈现，重写和隐藏很像，重写多被用于虚函数。

看望上面定义，我觉得大多仍然还是晕头转向的，这就对了！，想彻底搞懂这三者，那么我们接着往下看。

光看定义就想彻底搞懂重载、隐藏和重写？
没门！下面我们从具体代码实现来搞懂他们！我们依次对重载、隐藏和重写进行分析，先来看最简单的函数重载。

重载

对于函数重载来说，他不看重继承关系。也就是有没有继承关系，只要我想，我都可以发生重载。

无继承关系重载

代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    virtual void Show(double b)
    {
        cout << "Basic:virtual Show(double)" << b << endl;
    }
    virtual void Show(char c)
    {
        cout << "Basic:virtual Show(char)" << c << endl;
    }
};

int main(void)
{
    {
        Basic b;

        b.Show();    //void Show()
        b.Show(3);   //void Show(int a)
        b.Show(5.1); //virtual void Show(double b)
        b.Show('a'); //virtual void Show(char c)
    }

    system("pause");
    return 0;
}

运行结果如下
在这里插入图片描述
从上面我们可以看出，该程序先后调用了Basic类的构造函数、四个show方法和析构函数，可能有人会疑惑为什么main函数中会套一个大括号，其实这个目的是为了让我们能够显示的看到Basic类的析构函数被调用（即使不加大括号，Basic类的析构函数也会被调用，只是说不会被显示出来），加了大括号涉及到变量的生命周期问题，即此时b对象的生命周期只在大括号里，因此大括号结束即调用对象的析构函数，如果没有大括号，则调用析构函数会在main函数调用，不利于我们观察，因此这里加了大括号。

我们继续分析上述结果看能发生什么，首先我们能看到重载函数被正确调用。另外，这些重载函数中有虚函数和非虚函数，我们可以得出结论，可以对虚函数和非虚函数进行重载。

下面我们进一步分析：如果重载函数的返回值类型不一样呢？虚函数和非虚函数除了virtual外其余声明可以完全相同吗？
代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    int Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;

        return 1;
    }
    void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
};

显示结果
在这里插入图片描述从结果，我们可以看到，编译器直接报错了“无法重载仅按返回类型区分的函数”，即仅按照返回类型来区分重载不可行。

那么虚函数可以与非虚函数重载只相差一个virtual吗？
代码如下

void Show(double b)
    {
        cout << "Basic:virtual Show(double)" << b << endl;
    }
    virtual void Show(double b)
    {
        cout << "Basic:virtual Show(double)" << b << endl;
    }
    virtual void Show(char c)
    {
        cout << "Basic:virtual Show(char)" << c << endl;
    }

结果如下
在这里插入图片描述

这里结果显示，同样不能进行重载，和上面原因呢基本相同。

其实，对于这种结果，我们稍微想一想就可以明白，如果参数类型相同和个数，那么我们调用的时候怎么区分？我们调用的时候有用到返回类型吗？我们调用的时候有显示的写virtual了吗?如果没有，那么编译器怎么知道你想调用哪个函数？他是你肚子里的蛔虫吗？这些结论都显而易见，你们自己思考吧！

上面介绍晚了非继承关系的重载，其实继承关系的重载和非继承关系的重载相同，下面将简单介绍继承关系的重载。

继承关系重载

我们下面这段代码很有意思，代码中分别在基类和派生类中定义了特有的方法。首先，我们在基类中定义了Show方法，并对其进行了重载；然后，我们又定义了Basicshow方法，并且也对其进行了重载。接下来，我们使用Derive派生类来继承基类Basic，并且，在派生类中我们重新定义了两个Show方法（virtual void Show(double,int) 方法未在派生类中定义，这里有没有virtual都一样）；然后，我们又在派生类中定义了派生类特有的方法Deriveshow，并进行了重载，下面我们看代码实现

代码实现

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    virtual void Show(double b, int a)
    {
        cout << "Basic:virtual Show(double,int):" << b << "," << a << endl;
    }
    void BasicShow()
    {
        cout << "Basic:BasicShow(void)\n";
    }
    void BasicShow(int a)
    {
        cout << "Basic:BasicShow(int)" << a << endl;
    }
};
class Derive : public Basic
{
public:
    Derive()
    {
        cout << "Derive:call construct\n";
    }
    ~Derive()
    {
        cout << "Derive:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Derive:void Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Derive:void Show(int):" << a << endl;
    }
    void DeriveShow()
    {
        cout << "Derive:DeriveShow(void)\n";
    }
    void DeriveShow(int a)
    {
        cout << "Derive:DeriveShow(int)" << a << endl;
    }
};
int main(void)
{
    {
        //定义派生类对象
        Derive d;

        //基类函数，未在派生类中重定义
        d.BasicShow();  //Basic::void BasicShow()
        d.BasicShow(5); //Basic::void BasicShow(int a)
        //派生类特有的单独定义方法
        d.DeriveShow();  //Derive::void DeriveShow()
        d.DeriveShow(8); //Derive::void DeriveShow(int a)
        //派生类重新定义的基类方法(基类和派生类都有的)
        d.Show();  //Derive::void Show()
        d.Show(9); //Derive::void Show(int a)
        // d.Show(3.4,7);//error:派生类中未重新定义此类型
    }

    system("pause");
    return 0;
}

结果显示
在这里插入图片描述
我们对输出结果进行分析，首先从代码中我们可以看到在最后对函数进行调用时，我把d.Show(3.4,7)这个函数调用给注释掉了，之所以注释掉他，是因为调用他时代码会发生错误，至于为什么会发生错误，我们接下来会进行详细分析。我们继续看上面输出结果，输出结果中第三和第四行调用基类的方法BasicShow，然而这两个方法我们并未在派生类中定义，之所以父类能够调用这两个方法，就是因为派生类的继承特性，我相信大家对继承会有所了解。然后接下来两行又调用了派生类特有的方法DeriveShow，这里我相信大家也没什么疑问。再接下来，我们又调用了Show方法，不过我们如果深入思考一下就会发现，这个Show方法我们在基类和派生类中都有定义，但是，我们在派生类中只定义了基类中的两个Show方法，而我们定义的这两个Show方法恰恰可以在派生类中成功调用，而未在派生类中定义的这个Show方法却不能使用派生类对象调用。接着，我们再深入思考一下，程序中的输出结果显示了基类中的BasicShow方法可以使用派生类对象调用，并且这个BasicShow方法没有在派生类中定义；然而基类中的Show方法有三个，可是派生类只能调用其中的两个，并且这两个还都是在派生类中定义的。大家思考到这里，可能就会有点头绪了，为什么调用不了Show(double,int)，其实根本目的就是派生类的Show方法隐藏了基类的Show方法。
下面我们来详细探究一下C++的隐藏特性！

隐藏

何时发生隐藏？隐藏的结果是什么?

对于第一个问题，何时会发生隐藏呢，其实发生隐藏很简单，必须满足以下两个条件：

  • 有继承关系
  • 派生类中重新定义了基类的方法

对于第二个问题，隐藏的结果也很简单，就是派生类对象访问不了基类方法（只针对与隐藏的方法，不发生隐藏的仍然可以访问）

从上面那个代码就可以知道，派生类中重新定义了Show方法导致发生了隐藏，从而使得派生类对象访问不了基类中的Show方法。下面我们同样从代码分析隐藏，我们在分析之前可以先思考几个问题：

  • 发生隐藏的结果？
  • 虚函数会影响隐藏结果吗？

代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    void Show(double b, int a)
    {
        cout << "Basic:virtual Show(double,int):" << b << "," << a << endl;
    }
    void Show(int a, int b, int c)
    {
        cout << "Basic:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
class Derive : public Basic
{
public:
    Derive()
    {
        cout << "Derive:call construct\n";
    }
    ~Derive()
    {
        cout << "Derive:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Derive:void Show(void)\n";
    }
};
int main(void)
{
    {
        //定义派生类对象
        Derive d;
        //派生类重新定义的基类方法(基类和派生类都有的)
        d.Show(); //Derive::void Show()
        //d.Show(9); //error:发生了隐藏
        // d.Show(3.4,7);//error:发生了隐藏
        //d.Show(2,3,4);//error:发生了隐藏
    }

    system("pause");
    return 0;
}

结果如下
在这里插入图片描述
从结果可以看出，带派生类中只定义一个基类中的同名函数时，那么将只能调用这一个同名函数，剩余的几个将全部被隐藏。

如果基类定义的函数是虚方法并且派生类指定义了一个基类的同名方法呢？
这个结果和上面一样会隐藏，这里不再细说。
代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    virtual void Show(double b, int a)
    {
        cout << "Basic:virtual Show(double,int):" << b << "," << a << endl;
    }
    virtual void Show(int a, int b, int c)
    {
        cout << "Basic:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
class Derive : public Basic
{
public:
    Derive()
    {
        cout << "Derive:call construct\n";
    }
    ~Derive()
    {
        cout << "Derive:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Derive:Show(void)\n";
    }
};
int main(void)
{
    {
        Derive d;
        d.Show();
        d.Show(3);
        d.Show(3.5,6);
        d.Show(2,3,4);
    }

    system("pause");
    return 0;
}

结果如下
在这里插入图片描述

如果基类中的是虚方法并且派生类完全只定义了部分基类方法还会全部隐藏吗？
代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    virtual void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    virtual void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    virtual void Show(double b, int a)
    {
        cout << "Basic:virtual Show(double,int):" << b << "," << a << endl;
    }
    virtual void Show(int a, int b, int c)
    {
        cout << "Basic:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
class Derive : public Basic
{
public:
    Derive()
    {
        cout << "Derive:call construct\n";
    }
    ~Derive()
    {
        cout << "Derive:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Derive:Show(void)\n";
    }
};
int main(void)
{
    {
        Derive d;
        d.Show();
        d.Show(3);
        d.Show(3.5, 6);
        d.Show(2, 3, 4);
    }

    system("pause");
    return 0;
}

结果如下
在这里插入图片描述
我们看到只有在派生类中重新定义的Show方法才能成功调用，而其他方法都被隐藏。另外，这里重新定义的Show方法我们有了一个新的名称（上面也相同，如果派生类中的函数和基类中的函数完全相同，则说明派生类重写了基类的函数，那些未被重写的函数将被隐藏），叫做重写，而其他的未被重写的函数都被隐藏了。
下面我么来看一下重写

重写

重写，重写同样也是发生在继承关系中，在派生类中，对于在派生类中重新定义的与基类完全相同的同名函数被称作重写，而那些未被重写的同名函数将被隐藏，导致派生类不能访问，重写多出现于虚函数中，不是虚函数也可以发生重写。

下面我们通过代码来深入了解重写
代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    void Show(double a, double b)
    {
        cout << "Basic:void Show(double,double)\n";
    }
    virtual void Show(double b, int a)
    {
        cout << "Basic:virtual Show(double,int):" << b << "," << a << endl;
    }
    virtual void Show(int a, int b, int c)
    {
        cout << "Basic:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
class Derive : public Basic
{
public:
    Derive()
    {
        cout << "Derive:call construct\n";
    }
    ~Derive()
    {
        cout << "Derive:call destroy\n";
    }

public:
    void Show()
    {
        cout << "Derive:Show(void)\n";
    }
    void Show(int a)
    {
        cout << "Derive:Show(int):" << a << endl;
    }
    virtual void Show(double b, int a)
    {
        cout << "Derive:virtual Show(double,int):" << b << "," << a << endl;
    }
    virtual void Show(int a, int b, int c)
    {
        cout << "Derive:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
int main(void)
{
    {
        //父类指正指向子类对象
        Basic *p = new Derive;
        //派生类重新定义的基类方法(基类和派生类都有的)
        p->Show();        
        p->Show(9);      
        p->Show(3.4, 7);  
        p->Show(2, 3, 4); 
    }

    system("pause");
    return 0;
}

结果如下
在这里插入图片描述
在这段代码中，我们在基类中定义了五个Show方法，而派生类中只重写了其中四个基类方法（两个普通方法，两个虚方法）。我们在主函数中使用了父类指针指向子类的对象，然后通过这个父类指针来调用这四个方法，结果显示前两个方法调用的是基类的方法，后两个方法调用的是派生类的方法。我们观察一下可以看出，在父类中，前两个Show方法被定义成普通函数，而后两个方法被定义成虚函数，这就是为什么后两个方法调用的是派生类方法。

从上面我们知道当我们在基类中定义的方法为普通方法，在派生类中又重新定义了同名方法，基类中的同名方法会被隐藏，那么如果基类中的同名方法全都是虚方法，我在派生类中只定义了部分基类的方法，会发生什么呢？

代码如下

#include <iostream>

using namespace std;

class Basic
{
public:
    Basic()
    {
        cout << "Basic:call construct\n";
    }
    ~Basic()
    {
        cout << "Basic:call destroy\n";
    }

public:
    virtual void Show()
    {
        cout << "Basic:Show(void)\n";
    }
    virtual void Show(int a)
    {
        cout << "Basic:Show(int):" << a << endl;
    }
    virtual void Show(double a, double b)
    {
        cout << "Basic:void Show(double,double)\n";
    }
    virtual void Show(double b, int a)
    {
        cout << "Basic:virtual Show(double,int):" << b << "," << a << endl;
    }
    virtual void Show(int a, int b, int c)
    {
        cout << "Basic:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
class Derive : public Basic
{
public:
    Derive()
    {
        cout << "Derive:call construct\n";
    }
    ~Derive()
    {
        cout << "Derive:call destroy\n";
    }

public:

    virtual void Show(double b, int a)
    {
        cout << "Derive:virtual Show(double,int):" << b << "," << a << endl;
    }
    virtual void Show(int a, int b, int c)
    {
        cout << "Derive:void Show(int , int , int ):" << a << "," << b << "," << c << endl;
    }
};
int main(void)
{
    {
        //父类指正指向子类对象
        Basic *p = new Derive;
        //派生类重新定义的基类方法(基类和派生类都有的)
        p->Show(); 
        p->Show(9); 
        p->Show(2.3, 2.8);
        p->Show(3.4, 7);  
        p->Show(2, 3, 4); 
    }

    system("pause");
    return 0;
}

结果如下
在这里插入图片描述我们对结果进行分析，首先，我们应该知道，我们在基类中定义了5个Show方法，并且这5个Show方法都是虚方法；然后，我们又在派生类中重新定义了其中两个虚方法。然而，从结果显示，其他未被重新定义的虚方法并没用被隐藏，只是说在调用方法时如果调用的是重新定义的方法，则调用的是派生类中重新定义的方法，如果调用的是未重新定义的方法，则调用的是原本基类中的方法。
如果我们细心的观察其实会发现一些问题，其实派生类的这些方法也是被隐藏了，而输出结果之所以没有隐藏，那是因为问题出现在我们的调用方法上。在之前的代码我们都是使用派生类对象去调用的方法，而此处我们调用方法是使用的父类指针指向子类对象来调用方法，如果你在这里重新使用派生对象去调用，那么你同样会发现那些未被重写的函数同样被隐藏了。而这里之所以用父类指针指向子类对象来调用方法，目的是为了引出虚方法的一个特性：虚函数表！。

我相信，到这里，大家基本上都能动重载，隐藏和重写这三者的关系了，下面我们再来简单聊一聊虚函数表！

虚函数表

虚函数表从名字我们就可以听出来他是专门为虚函数来准备的，那么虚函数表的作用是什么？

其实我们从上面那个代码就可以看出来，为什么当父类指针指向子类对象时父类指针调用的就是派生类的方法，而且派生类方法只重写了部分的基类方法，其余的方法却没有被隐藏？
这其实都是虚函数表的功劳，当类中有虚函数出现时，类中会自动床架一个虚函数表，虚函数表中存储的就是虚函数的地址，当使用父类指针指向子类对象时，就从虚函数表中查找函数地址，来调用虚方法。每当有一个虚方法，就会将虚方法添加进虚函数表，每一个类只要有虚函数，就会有属于自己的虚函数表。当父类指针有虚函数时，便有了一个虚函数表，子类继承父类时，同样将父类的虚函数表继承了下来，如果子类中重写了父类的虚函数，那么只将对应的虚函数表中的函数地址更新，而其他的函数地址不变，这就是为什么当子类只重写类部分的父类方法，其他的父类方法仍然不会被隐藏的原因。

结论

  • 重载至于函数的参数列表有关（类型，个数，顺序），而与返回值类型、是否是虚函数无关
  • 隐藏和重写只发生在继承关系中
  • 当派生类重写了基类的同名方法，其他未被重写的同名方法将被隐藏
  • 对于基类中的虚方法，当调用方式为父类指针指向子类对象时，即使子类只重写部分父类的方法，同样可以使用父类指针调用那些未被重写的方法（虚函数表、多态）
  • 对于基类中的虚方法，当调用方式为派生类对象调用时，那些未被重写的方法同样会发生隐藏。

结束语：哎呀，终于写完了！写这么多字不容易啊！如果大家觉得文章对你有帮助，欢迎大家关注，评论，点赞，转发，您的支持就是我创作的最大动力！

Bug.Remove()
关注
专栏目录
【极富参考价值！】第1章 ClickHouse 简介《ClickHouse 企业级大数据分析引擎实战》...
AI天才研究院
12-13 9480
《ClickHouse 企业级大数据分析引擎实战》全书目录目录第1章 ClickHouse 简介第2章 MergeTree 表存储引擎第3章 ClickHouse SQL 执行原理第4章 ...
c++ 重载、覆盖、重写
04-19
这篇文章主要介绍了C++中重载、重写（覆盖）和隐藏的区别,是C++面向对象程序设计非常重要的概念,需要的朋友可以参考下
C++重写（覆盖）、重载、重定义、多态
weixin_30757793的博客
06-22 410
1 重写（覆盖）override 　　override是重写（覆盖）了一个方法，以实现不同的功能。一般用于子类在继承父类时，重写（覆盖）父类中的方法。函数特征相同，但是具体实现不同。 重写需要注意： 被重写的函数不能是static的，必须是virtual的 重写函数必须有相同的类型，名称和参数列表 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重写改写为...
C++的重载
最新发布
weixin_44259499的博客
08-30 348
函数重载：允许在同一作用域内定义多个同名函数，通过不同的参数列表（类型、数量或顺序）进行区分。它提高了代码的灵活性和可读性。运算符重载：允许为运算符赋予新的意义，使其可以操作用户自定义的类型。这使得自定义类型的对象也可以像基本数据类型一样方便地使用运算符。重载是C++语言的重要特性之一，它赋予了开发者在编写代码时更大的灵活性和表达能力。理解和熟练使用重载对于编写高效、可维护的C++代码至关重要。
C++ 重载，重写，覆盖
weixin_42145502的博客
07-14 147
https://www.cnblogs.com/tianzeng/p/9775672.html https://blog.csdn.net/warpar/article/details/73466672 重写覆盖demo： #include "iostream" using namespace std; class Base { public: virtual void test...
C++重载、覆盖与隐藏
weixin_37977062的博客
03-20 307
重载 前提：(1)同一作用域 (2)函数名相同 要求：不同形参表 注： 返回类型和参数的缺省值不参与重载识别。函数前缀的访问控制（public/protected/private）不影响重载。在不同的名字空间声明的函数不是重载。除 main 函数之外的任何函数都可以重载。 重载的几种情况： (1) 形参是引用，非引用时 void
覆盖、重载、隐藏
ali_sure的专栏
11-08 727
多态 ...我猜楼主是问的 覆盖、重载、隐藏吧？ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝“overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖,使原来的失去效果。先来说说重载的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服的方式来洗一件衣服，但是谁也不会用
面向对象之16：一文 彻底搞懂Java中的泛型、泛型的 使用细节 及 注意事项：
随手记记，加深印象。
06-15 1037
what's Generic？ 泛型（广泛的类型）： 泛型就相当于是一个标签。形象一些就是：在生活中随处可见的类似于泛型的参考。比如：男卫生间门上贴的标签 --》 男 or boy ，女卫生间门上的标签 --》 女 or girl，能表示性别的标签 理解在Java中就叫做泛型。再 比如：垃圾分类的垃圾桶上面贴的标签，比如：厨余辣鸡、有害辣鸡、可回收辣鸡、其他辣鸡，……等等。 泛型的声明格式：<泛型标识符[,泛型标识符2,……]> 这个<>有的 因为像，也叫做钻石运算符。 Java中 泛型的
【网络编程】一文搞定Netty，打造单机百万连接测试！
互联网小阿祥
11-03 4120
一文搞定Netty，打造单机百万连接测试！
一文带你深扒ClassLoader内核，揭开它的神秘面纱！
我没有三颗心脏的博客
08-28 394
「MoreThanJava」 宣扬的是 「学习，不止 CODE」。 如果觉得 「不错」 的朋友，欢迎 「关注 + 留言 + 分享」，文末有完整的获取链接，您的支持是我前进的最大的动力！ 前言 ClassLoader 可以说是 Java 最为神秘的功能之一了，好像大家都知道怎么回事儿 (双亲委派模型好像都都能说得出来…)，又都说不清楚具体是怎么一回事 (为什么需要需要有什么实际用途就很模糊了…)。 今天，我们就来深度扒一扒，揭开它神秘的面纱！ Part 1. 类加载是做什么的？ 首先，我们知道，Ja..
【Java基础知识 1】Java入门级概述
热门推荐
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
C++函数的重载和覆盖
05-24
一个技术文档，记录一些关于C++方面的函数的重载和覆盖方法，可供参考
c++ 重载、重写、覆盖
David
09-19 656
【代码】c++ 重载、重写、覆盖。
C++重载、重写、覆盖
m0_50313114的博客
05-21 1586
函数重载：在作用域中,函数名同名，函数参数顺序类型个数不同时构成重载 使用const 修饰也可以构成重载，使用默认参数时要注意调用时避免与其他函数存在二异性 1)函数返回值与构成函数重载无任何关系 2)类的静态成员函数与普通成员函数可以形成重载 3)函数重载发生在同一作用域中，如类成员函数之间的重载、全局函数之间的重载 4)基类函数必须有 virtual 关键字，不能有 static，大概是多态的原因 函数重写：在派生类中对基类成员函数的返回值类型、函数名、参数列表相同的函数重新定义，也
C++学习：重载，重写和覆盖
qq_34672406的博客
01-05 747
C++学习：重载，重写和重定义重写（覆盖） override重载 overload重定义redefining多态 重写（覆盖） override override是重写（覆盖）了一个方法，以实现不同的功能。一般用于子类在继承父类时，重写（覆盖）父类中的方法。函数特征相同，但是具体实现不同。 重写需要注意： 被重写的函数不能是static的，必须是virtual的 重写函数必须有相同的类型，名称和...
C++ 重载、重写(覆盖)、隐藏
qq_38409301的博客
05-26 948
以前没认真分辨这几个概念的区别，今天记录一下。 转载：为什么const对象只能调用const成员函数，而不能调用非const成员函数？ - 阿瞒123 - 博客园 (cnblogs.com) 重点： 1.重载只能在一个类中。 2.重写只能在子类和派生类中。 3.隐藏只能是子类和派生类中。 4.重载可以重载const(很有意思)，非常量对象也可以调用常成员函数，但是如果有重载的非常成员函数则会调用非常成员函数。 1.重载：就是在一个类中声明同名和返回值类型相同的函数，但参数不同 2.重
C++重载、重写（覆盖）和隐藏
大千世界
11-28 508
重载、重写（覆盖）、隐藏 1、重载（overload） 指在同一可访问区域内被声明的几个具有不同参数列表（参数的类型、个数、顺序不同）的同名函数，根据参数列表确定调用哪个函数，重载并不关心函数返回值。 2、隐藏 指派生类的函数屏蔽了与其同名的基类函数，注意只要同名函数，不管参数列表是否相同，基类函数都会被隐藏。 3、重写（覆盖）（override） 指派生类中存在重新定义的函数。其函数名、参数列表...
【C++】重载覆盖和隐藏
GoingJack博客
07-16 282
理论知识 1，重载关系 一组函数要重载必须要处于同一作用域当中，而且函数名字相同，参数列表不同。 3，覆盖关系 基类和派生类的方法，返回值、函数名以及参数列表都相同，而且基类的方法是虚函数， 那么派生类的方法就自动处理成虚函数，它们之间成为覆盖关系 2，隐藏关系 在继承结构中，派生类的同名成员 把基类的同名成员给隐藏调用了。 例子 第一个 #include<iostr...
C++中重载、重写（覆盖）的区别实例分析
HuangQinJian
01-29 7093
这篇文章主要介绍了C++中重载、重写（覆盖）的区别,是C++面向对象程序设计非常重要的概念,需要的朋友可以参考下。
一文看懂linux内核!linux内核架构和工作原理详解
07-22
### 回答1： Linux内核是一种开源的操作系统内核，是Linux操作系统的核心组成部分。它提供了操作系统与硬件之间的抽象层，负责管理系统的资源、调度任务、提供驱动程序等功能。 Linux内核采用分层的架构，包括硬件抽象层、系统调用层、进程管理层、文件系统层和网络层等。硬件抽象层负责将不同硬件设备的接口统一起来，使得上层的软件可以方便地与硬件进行通信。系统调用层提供了一组API供用户进程调用，如文件操作、网络通信等。进程管理层负责进程的创建、销毁以及调度等任务。文件系统层负责文件的管理和存储。网络层负责网络协议的实现和网络通信。 Linux内核的工作原理可以简单概括为以下几个关键步骤。首先，当一台计算机启动时，BIOS会加载内核映像到内存中，并执行启动代码。然后，内核初始化各种数据结构、驱动程序和关键服务。接下来，内核创建一个初始的用户空间进程，称为init进程。init进程是所有其他进程的祖先进程。在此之后，内核根据调度算法来决定哪个进程可以使用CPU，并依次执行。同时，内核会提供一个中断机制，以便处理硬件事件的优先级。 内核还提供了许多系统调用供用户进程调用，以实现对各种功能的访问。当用户进程需要操作文件、创建进程或进行网络通信时，会通过系统调用将请求传递给内核，由内核代表用户进程执行相应的操作。内核通过调度算法来分配CPU时间片，并通过虚拟内存管理来管理内存资源的分配和回收。 总而言之，Linux内核是一个高度可配置和模块化的操作系统内核，通过分层架构和系统调用机制实现了对硬件的抽象和对用户进程的管理。了解Linux内核的架构和工作原理，有助于深入理解Linux操作系统以及开发和调试相关应用程序。 ### 回答2： Linux是一种开源的操作系统内核，其设计目标是为了在不同的计算机硬件平台上提供高效的、稳定的和安全的操作系统服务。 Linux内核的架构可以分为三个主要部分：进程管理、内存管理和文件系统管理。 在进程管理方面，Linux内核使用了多任务处理技术，可以同时运行多个进程。每个进程都有独立的地址空间和资源，通过调度算法可以合理分配CPU时间片，优化系统的响应速度和资源利用率。 在内存管理方面，Linux内核使用了虚拟内存技术，将物理内存和逻辑内存进行了映射，使得每个进程都有独立的地址空间。当物理内存不足时，Linux内核会通过页面置换算法将暂时不使用的页写入磁盘交换空间，以释放物理内存供其他进程使用。 在文件系统管理方面，Linux内核支持多种文件系统，包括传统的ext3和ext4文件系统，以及现代的Btrfs和XFS文件系统。它负责文件的读写操作，以及文件的权限控制和磁盘空间的管理。 Linux内核的工作原理可以简单概括为以下几个步骤：首先，启动引导程序将内核加载到内存中，并进行初始化。然后，内核分配一部分内存作为内核空间，用于存放内核代码和数据结构。接着，内核根据系统的硬件配置进行设备的初始化和驱动程序的加载。之后，内核根据系统的启动参数和配置文件进行一系列的初始化工作，包括启动系统服务和加载用户程序。最后，内核进入主循环，不断地处理中断、调度进程、管理内存和文件系统，以提供稳定的操作系统服务。 总之，Linux内核是一个复杂而高效的软件系统，它通过进程管理、内存管理和文件系统管理等功能，实现了操作系统的基本功能。了解Linux内核的架构和工作原理，有助于我们更好地理解和使用这个优秀的开源操作系统。 ### 回答3： Linux内核是一个开放源代码的操作系统内核，由一个核心程序和一组通用的系统工具组成。它是Linux操作系统的核心，负责处理硬件设备、管理系统资源、实现进程管理、文件系统和网络功能等。 Linux内核的架构可以分为两个层次：用户空间和内核空间。用户空间包括用户应用程序，如图形界面、终端程序等，它们通过系统调用接口与内核进行通信。内核空间包括内核核心的数据结构和程序，用于管理和控制硬件资源。 Linux内核的工作原理可以概括为以下几个方面： 1. 进程管理：内核负责创建、调度和终止进程。它使用进程描述符（task_struct）来跟踪进程的状态和资源使用情况，并根据调度算法分配CPU时间片给不同的进程。 2. 内存管理：内核负责管理系统的物理内存和虚拟内存。物理内存管理包括内存分配和释放，虚拟内存管理包括页面置换和页面回写等策略，以优化内存的使用效率。 3. 文件系统：内核提供文件系统接口，管理文件和目录的创建、读写和删除等操作。它通过虚拟文件系统层（VFS）将不同的文件系统统一管理，如ext4、NTFS等。 4. 设备驱动：内核提供了访问硬件设备的接口，通过设备驱动程序与硬件交互。不同的硬件设备需要不同的驱动程序，如网卡、显卡、声卡等。 5. 网络功能：内核提供TCP/IP协议栈和网络设备驱动程序，用于实现网络通信功能。它提供网络连接的建立、数据传输和断开等功能，支持各种网络协议，如HTTP、FTP、SSH等。 总的来说，Linux内核是一个非常复杂且功能强大的软件，它负责管理计算机的各种资源和提供操作系统的各种功能。通过深入理解其架构和工作原理，我们可以更好地理解和使用Linux操作系统。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bug.Remove()

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值