类成员函数的重载、覆盖和隐藏区别

最新推荐文章于 2022-07-06 17:58:58 发布

Wonder233

最新推荐文章于 2022-07-06 17:58:58 发布

阅读量690

点赞数

文章标签： c++ 对象

C++ 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

重载：

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual 关键字可有可无。

#include <iostream>

using std::cin;
using std::cout;
using std::endl;

class A
{
public:
    void show(int val) { cout << val; }
    void show(double val) { cout << val; }
};

int main(void)
{
    A a;
    a.show(4);
    cout << endl;
    a.show(4.2);
    cin.get();
}

覆盖（重写）：

覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual 关键字。

#include <iostream>

using std::cin;
using std::cout;
using std::endl;

class A
{
public:
    virtual void show(int val) { cout << val; }
};

class B : public A
{
public:
    void show(int val) { cout << "--" << val << "--"; }
};

int main(void)
{
    A a;
    a.show(4);
    cout << endl;

    A* p = new B;
    p->show(5);

    cin.get();
}

隐藏：

隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，且参数也相同，但基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

（3）但是，《Effective C++》条款36说：绝不重新定义继承而来的non-virtual函数，所以就不要这么做了。

这三个概念都是与OO中的多态有关系的。如果单是区别重载与覆盖这两个概念是比较容易的，但是隐藏这一概念却使问题变得有点复杂了，下面说说它们的区别吧。

重载是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。

覆盖（也叫重写）是指在派生类中重新对基类中的虚函数（注意是虚函数）重新实现。即函数名和参数都一样，只是函数的实现体不一样。

隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了。隐藏与另外两个概念表面上看来很像，很难区分，其实他们的关键区别就是在多态的实现上。什么叫多态？简单地说就是一个接口，多种实现吧。

还是引用一下别人的代码来说明问题吧（引用自林锐的《高质量C/C++编程指南》）。

仔细看下面的代码：

#include <iostream.h>  
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; } 
};

看出什么了吗？下面说明一下：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

嗯，概念大概明白了，但是在实际的编程中，我们会因此遇到什么问题呢？再看下面的代码：

void main(void)  
{  
Derived  d;  
Base *pb = &d;  
Derived *pd = &d; 
 
// Good : behavior depends solely on type of the object  
pb->f(3.14f); // Derived::f(float) 3.14  
pd->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  
pd->g(3.14f); // Derived::g(int) 3        (surprise!)  

// Bad : behavior depends on type of the pointer  
pb->h(3.14f); // Base::h(float) 3.14      (surprise!)  
pd->h(3.14f); // Derived::h(float) 3.14  
}

在第一种调用中，函数的行为取决于指针所指向的对象。在第二第三种调用中，函数的行为取决于指针的类型。所以说，隐藏破坏了面向对象编程中多态这一特性，会使得OOP人员产生混乱。
不过隐藏也并不是一无是处，它可以帮助编程人员在编译时期找出一些错误的调用。但我觉得还是应该尽量使用隐藏这一些特性，该加virtual时就加吧。

成员函数被重载的特征
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

“overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖,使原来的失去效果。

先来说说重载的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服的方式来洗一件衣服，但是谁也不会用洗衣服的方式来洗一辆车，否则等洗完时车早就散架了。我们并不要那么明确地指出来就心知肚明，这就有重载的意思了。在同一可访问区内被声名的几个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调用哪个函数，这种机制叫重载，重载不关心函数的返回值类型。这里，“重载”的“重”的意思不同于“轻重”的“重”，它是“重复”、“重叠”的意思。例如在同一可访问区内有：

① double calculate(double);

② double calculate(double，double);

③ double calculate(double, int);

④ double calculate(int, double);

⑤ double calculate(int);

⑥ float calculate(float);

⑦ float calculate(double);

六个同名函数calculate，①②③④⑤⑥中任两个均构成重载，⑥和⑦也能构成重载，而①和⑦却不能构成重载，因为①和⑦的参数相同。

覆盖是指派生类中存在重新定义的函数，其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致，覆盖函数和被覆盖函数只有函数体（花括号中的部分）不同，当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本，这种机制就叫做覆盖。

下面我们从成员函数的角度来讲述重载和覆盖的区别。

成员函数被重载的特征有：

1) 相同的范围（在同一个类中）；

2) 函数名字相同；

3) 参数不同；

4) virtual关键字可有可无。

覆盖的特征有：

1) 不同的范围（分别位于派生类与基类）；

2) 函数名字相同；

3) 参数相同；

4) 基类函数必须有virtual关键字。

比如，在下面的程序中：

#include <iostream.h>
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
class Derived : public Base
{
public:
virtual void g(void){ cout << "Derived::g(void)" << endl;}
};
void main(void)
{
Derived d;
Base *pb = &d;
pb->f(42); // 运行结果: Base::f(int) 42
pb->f(3.14f); // 运行结果: Base::f(float) 3.14
pb->g(); // 运行结果: Derived::g(void)
}

函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。

隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

1) 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

2) 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

比如，在下面的程序中：

#include <iostream.h>
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; }
};

通过分析可得：

1) 函数Derived::f(float)覆盖了Base::f(float)。

2) 函数Derived::g(int)隐藏了Base::g(float)，注意，不是重载。

3) 函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

看完前面的示例，可能大家还没明白隐藏与覆盖到底有什么区别，因为我们前面都是讲的表面现象，怎样的实现方式，属于什么情况。下面我们就要分析覆盖与隐藏在应用中到底有什么不同之处。在下面的程序中bp和dp指向同一地址，按理说运行结果应该是相同的，可事实并非如此。

void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); //运行结果: Derived::f(float) 3.14
pd->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
pd->g(3.14f); //运行结果: Derived::g(int) 3
// Bad : behavior depends on type of the pointer
pb->h(3.14f); //运行结果: Base::h(float) 3.14
pd->h(3.14f); //运行结果: Derived::h(float) 3.14
}

请大家注意，f()函数属于覆盖，而g()与h()属于隐藏。从上面的运行结果，我们可以注意到在覆盖中，用基类指针和派生类指针调用函数f()时，系统都是执行的派生类函数f()，而非基类的f()，这样实际上就是完成的“接口”功能。而在隐藏方式中，用基类指针和派生类指针调用函数f()时，系统会进行区分，基类指针调用时，系统执行基类的f()，而派生类指针调用时，系统“隐藏”了基类的f()，执行派生类的f()，这也就是“隐藏”的由来。

3种情况怎么执行：

1。重载：看参数

2。隐藏：用什么就调用什么

3。覆盖：调用派生类

class People {
public:
    // 隐藏:是指派生类的函数屏蔽基类函数
    // 隐藏规则1：
    // 1) 函数名相同 && 参数不同
    // 2) virtual不影响
    void getId_different_params() {cout << "People::getId_different_params" << endl;}
    virtual void getName_different_params() {cout << "People::getName_different_params" << endl;}
 
    // 隐藏规则2:
    // 1) 函数名相同 && 参数相同
    // 2) 无virtual
    void getPhone_same_params() {cout << "People::getPhone_same_params" << endl;}
 
    // 覆盖规则:
    // 1) 函数名相同 && 参数相同
    // 2) 有virtual
    virtual void getAddress_same_params() {cout << "People::getAddress_same_params" << endl;}
};
 
class Children : public People {
public:
    // 隐藏:是指派生类的函数屏蔽基类函数
    // 隐藏规则1：
    // 1) 函数名相同 && 参数不同
    // 2) virtual不影响
    void getId_different_params(int) {cout << "Children::getId_different_params(int)" << endl;}
    virtual void getName_different_params(int) {cout << "Children::getName_different_params(int)" << endl;}
 
    // 隐藏规则2:
    // 1) 函数名相同 && 参数相同
    // 2) 无virtual
    void getPhone_same_params() {cout << "Children::getPhone_same_params" << endl;}
 
    // 覆盖规则:
    // 1) 函数名相同 && 参数相同
    // 2) 有virtual
    virtual void getAddress_same_params() {cout << "Children::getAddress_same_params" << endl;}
};