C++多态、重载、覆盖、隐藏

最新推荐文章于 2022-06-06 22:18:18 发布

炫橘子上火

最新推荐文章于 2022-06-06 22:18:18 发布

阅读量469

点赞数 4

分类专栏： # C++

本文链接：https://blog.csdn.net/phdongou/article/details/117770496

版权

C++ 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

C++多态、重载、覆盖、隐藏

1. 多态

在基类中定义一个虚函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态采用了动态绑定技术。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声类中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。

一个操作随着所传递或捆绑的对象类型的不同能够做出不同的反应，其行为模式称为多态。

c++使用滞后捆绑技术支持多态，这种技术通过预先设定其成员函数的虚函数性质，使得任何捆绑该成员函数的未定类型的对象操作在编译时，都以一个不确定的指针特殊的“引命待发”来编码，到了运行时，遇到确定类型的对象，才突然指定其真正的行为。即滞后到运行时根据具体类型的对象来捆绑成员函数。这样一来，辨别对象类型的工作就可以不用用户做了。

例子：

#include <iostream>
using namespace std;
class A
{
public:
   virtual void ShowMessage();
};

class B:public A
{
public:
  void ShowMessage();
};

void A::ShowMessage()
{
  cout<<"This is A./n";
  return;
}

void B::ShowMessage()
{
  cout<<"This is B./n";
  return;
}

int main()
{
  A* p;
  p=new A();
  p->ShowMessage();
  p=new B();
  p->ShowMessage();
  return 0;
}

输出：
This is A.
This is B.

2. 重载

成员函数被重载的特征：

相同的范围（在同一个类中）
函数名字相同
参数不同
virtual关键字可有可无

3. 覆盖

覆盖是指派生类函数覆盖基类函数。

特征是：

不同的范围（分别位于派生类与基类）；
函数名字相同；
参数相同；
基类函数必须有virtual关键字。

C++的多态行为，应该就是覆盖表现出来的。

例子：

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

#include <iostream>

class Base
{
public:

    void f(int x)
    {
        std::cout << "Base::f(int) " << x <<std::endl;
    }

    void f(float x)
    {
        std::cout << "Base::f(float) " << x <<std::endl;
    }

    virtual void g(void)
    {
        std::cout << "Base::g(void)" <<std::endl;
    }

};



class Derived : public Base
{

public:

    virtual void g(void)
    {
        std::cout << "Derived::g(void)" <<std::endl;
    }

};



int main(void)
{
    Derived d;

    Base *pb = &d;

    pb->f(42);        // Base::f(int) 42
    d.f(42);

    pb->f(3.1415926f);     // Base::f(float) 3.14
    d.f(3.1415926f);

    pb->g();          // Derived::g( )
    d.g();

    return 0;
}

4. 隐藏

本来仅仅区分重载和覆盖并不算困难，但C++的隐藏规则却使问题变得较为复杂，开始难以理解了。那什么时候发生隐藏呢？

以下两种情况下会发生隐藏：（二者分别对应不能满足上述重载和覆盖条件的两种情况）

如果派生类函数与基类函数同名，但参数不同（特征标不同），此时，无论是否有virtual关键字，基类的所有同名函数都将被隐藏。（注：此时不满足重载条件，因为不在同一个类中）
如果派生类函数与基类函数同名，且参数也相同（特征标相同），但基类函数没有用virtual关键字声明，则基类的所有同名函数都将被隐藏。（注：此时不满足覆盖条件，因为基类没有声明为虚函数。）

隐藏后，在子类中便会看不到父类的函数。

4.1 隐藏存在的理由

即然隐藏如此烦人，那它有什么存在的理由吗？

先看一段代码：

#include <iostream>


class Base
{

public:

    void f(int x)
    {

    }

};

class Derived : public Base

{
public:

    void f(char *str)
    {

    }

};

int main(void)

{

    Derived *pd = new Derived;
    pd->f(10);          // error

    pd->Base::f(10);    // right

    Derived d;
    d.f(10);            // error
    d.Base.f(10);       // right
}

看上面这段代码，我们可以发现隐藏规则至少有两点存在的理由：

写语句pd->f(10)的人可能真的想调用Derived::f(char *)函数，只是他误将参数写错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编译器会静悄悄地将错就错，程序员将很难发现这个错误，流下祸根。
假如类Derived有多个基类（多重继承），有时搞不清楚哪些基类定义了函数f。如果没有隐藏规则，那么pd->f(10)可能会调用一个出乎意料的基类函数f。尽管隐藏规则看起来不怎么有道理，但它的确能消灭这些意外。

当然，如果语句pd->f(10)一定要调用函数Base::f(int)，那么将类Derived修改为如下即可。

#include <iostream>


class Base
{

public:

    void f(int x)
    {

    }

};



class Derived : public Base

{

public:

    void f(char *str)
    {

    }

    void f(int x)
    {

        Base::f(x);
    }

};


int main(void)
{

    //Derived *pd = new Derived;
    Derived d;
    d.f(10);

}

4.2 名字空间中也可能发生隐藏

不一定非得是在类中才会发生隐藏，在类外讨论时，也可能发生隐藏，比如在名字空间中。看下面这段代码：

#include <iostream>
using namespace std;

void foo(void) { cout << "global foo()" << endl; }
int foo(int x) { cout << "global foo(int)" << endl; return x; }

namespace a
{
    void foo(void) { cout << "a::foo()" << endl; }
    void callFoo(void)
    { 
        foo();
        //foo(10); //Can't be compiled! 
    }
}

int main(int argc, char** argv)
{
    foo();
    a::callFoo();
    return 0;
}

输出：
global foo()
a::foo()

注意，名字空间a中的foo隐藏了其它作用域（这里是全局作用域）中的所有foo名称，foo(10)不能通过编译，因为全局作用域中的int foo(int)版本也已经被a::foo()隐藏了，除非使用::foo(10)显式进行调用。

这其实也告诉我们，无论何时都使用完整名称修饰（作用域解析符调用函数，或指针、对象调用成员函数），真的是一种好的编程习惯。