C++中的重载、覆盖、隐藏


前几天面试时被问及C++中的覆盖、隐藏，概念基本答不上来，只答了怎么用指针实现多态，也还有遗漏。最终不欢而散。回来后在网上查找学习了一番，做了这个总结。

  • 概念

一、重载（overload）
指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。
（1）相同的范围（在同一个作用域中） ；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
（5）返回值可以不同；

二、重写（也称为覆盖 override）
是指派生类重新定义基类的虚函数，特征是：
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有 virtual 关键字，不能有 static 。
（5）返回值相同（或是协变），否则报错；<—-协变这个概念我也是第一次才知道…

（6）重写函数的访问修饰符可以不同。尽管 virtual 是 private 的，派生类中重写改写为 public,protected 也是可以的

三、重定义（也成隐藏）
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同。此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及覆盖混淆） 。
（5）参数相同，但是基类函数没有 virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆） 。

  • 例子

#include <iostream>

using namespace std;

class SParent
{
public:
    SParent( ){};

    SParent( const SParent &p )
    {
        cout << "parent copy construct" << endl;
    }

    int add( int a,int b )
    {
        cout << "parent int add" << endl;
        return a + b;
    }

    double add( double a,double b )
    {
        cout << "parent double add" << endl;
        return a + b;
    }

    virtual int dec( int a,int b )
    {
        cout << "parent int dec" << endl;
        return a - b;
    }
};

class SChild : public SParent
{
public:
    //using SParent::add;
    float add( float a,float b )
    {
        cout << "child float add" << endl;
        return a + b;
    }

    int dec(int a, int b)
    {
        cout << "child int dec" << endl;
        return a - b;
    }
};

int main()
{
    /* 测试重载 */
    SParent parent;
    parent.add( 3,5 );
    parent.add( (double)3,(double)5 );
    cout << endl;

    /* 测试覆盖 */
    SChild *pchild = (SChild *)new SParent();/* 基类强转为子类...危险...,用dynamic_cast转换也不行 */
    pchild->dec( 10,3 );

    SParent *pparent = new SChild();
    pparent->dec( 11,3 );
    cout << endl;

    /* 测试隐藏 */
    SChild child;
    child.add( (int)3,(int)5 );

    cout << endl;

    /* 测试函数表 */
    ((SParent *)NULL)->add( 4,6 );
    ((SChild *)NULL)->add( 4,6 );
    int a = 0;
    ((SChild *)&a)->add( 4,6 );

    cout << endl;

    /* 测试函数地址 */
    ((SParent)child).add( (int)4,(int)8 );
    child.SParent::add( 3,5 );


    return 0;
}

输出结果：

parent int add
parent double add

parent int dec
child int dec

child float add

parent int add
child float add
child float add

parent copy construct
parent int add
parent int add
按 <RETURN> 来关闭窗口...

理解

int SParent::add(int a,int b)与double SParent::add( double a,double b )是重载

int SParent::add(int a,int b)与double SParent::add( double a,double b )都被子类SChild中的float SChild::add( float a,float b )隐藏

int SParent::dec( int a,int b )被子类SChild中的int SChild::dec( int a,int b )覆盖

  • 测试

1.重载测试，简单易懂，略过。

2.覆盖测试。dec函数在基类、子类中同名同参，为虚函数，故称覆盖。

SChild *pchild = (SChild *)new SParent()创建的是一个基类对象，其函数表应该为

SParent *pparent = new SChild();创建一个子类对象，其函数表应该为

由上面的函数表可见，当发生覆盖时，子类的函数名会把基类的同名函数覆盖(这也就是为什么叫覆盖的原因吧)。这样我们可以利用一个指向子类的基类指针实现多态。但重点只有一

个，就是函数表里到底指向谁(不管这个指针经过转换后是什么类型的).故输出分别为父类、子类。这是一个运行时多态。

3.隐藏测试

int SParent::add(int a,int b)与double SParent::add( double a,double b )都被子类SChild中的float SChild::add( float a,float b )覆盖，是因为他们同名，而且在不同的作用域中(基类、子类作用域是不同的)。child.add( (int)3,(int)5 );这行代码中，编译器在子类中查找add函数，只找到了一个(基类的add(int a,int b)会被编译根据隐藏规则略过），再根据隐式类型转换发现该函数适用。如果无法隐式转换，则编译不过。隐藏的原因：防止隐式类型转换造成错误。比如int也是可以转换成char的，假如基类有一函数add(char a,char b)，子类也有一函数add(double a,double b)。程序员想着在子类隐式把int转换为double，但编译器可能调的是基类的。这也防止了一些库或封装好的基类对程序员造成困扰。

　　像上面的代码，如果你确实需要基类的函数，可以用using SParent:add。则把基类的add函数域扩大到了子类，构成重载。

4.函数表测试

上面我们说到函数表，这个是在编译时定好的，程序运行时加载到内存中。这意味着我们可以直接通过地址去调用函数。所以((SChild *)NULL)->add( 4,6 );这种代码也是能运行通过的。网上还有人通过计算直接取到了函数表的地址直接调用了。但这种代码不安全不规范不说，还有个更大的问题。当成员函数里需要调用成员变量时，通过这种假的对象指针肯定找不到成员变量表，直接访问了非法内存。

5.函数地址测试

有了隐藏、覆盖，哪么我们要怎么调用被隐藏、覆盖的函数呢。下面有两种方法：

    ((SParent)child).add( (int)4,(int)8 );
    child.SParent::add( 3,5 );

第一种是比较低效的方法。事实上它是通过拷贝构造函数生成一个临时的基类变量去调用基类的add函数。

第二种通过::指定域去访问。这种方法是编译器根据域直接找到了基类的函数地址，跟函数表没有多大关系。

本文永久更新链接地址：

相关内容