重载、覆盖、多态与函数隐藏--1

首先，我们来看一个非常简单的例子，理解一下什么叫函数隐藏hide。
#include <iostream>
using namespace std;

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

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

int main()
{
    Derive d;
    //下面一句错误，故屏蔽掉
    //d.fun();error C2660: 'fun' : function does not take 0 parameters
    d.fun(1);

    Derive *pd =new Derive();
    //下面一句错误，故屏蔽掉
    //pd->fun();error C2660: 'fun' : function does not take 0 parameters
    pd->fun(1);
    delete pd;
    
    return 0;
}
/*在不同的非命名空间作用域里的函数不构成重载,子类和父类是不同的两个作用域。
在本例中,两个函数在不同作用域中,故不够成重载,除非这个作用域是命名空间作用域。*/

在这个例子中，函数不是重载overload，也不是覆盖override，而是隐藏hide。


接下来的5个例子具体说明一下什么叫隐藏

例1
#include <iostream>
using namespace std;

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

class Derive :public Basic{
public:
         void fun2(){cout << "Derive::fun2()" << endl;}
};

int main()
{
         Derive d;
         d.fun();//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。
         d.fun(1);//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。
         return 0;
}
 

例2
#include <iostream>
using namespace std;

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

class Derive :public Basic{
public:
         //新的函数版本,基类所有的重载版本都被屏蔽,在这里,我们称之为函数隐藏hide
    //派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。
         void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}
         void fun2(){cout << "Derive::fun2()" << endl;}
};

int main()
{
         Derive d;
         d.fun(1,2);
         //下面一句错误，故屏蔽掉
         //d.fun();error C2660: 'fun' : function does not take 0 parameters
         return 0;
}
例3
#include <iostream>
using namespace std;

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

class Derive :public Basic{
public:
         //覆盖override基类的其中一个函数版本,同样基类所有的重载版本都被隐藏hide
    //派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。
         void fun(){cout << "Derive::fun()" << endl;}
         void fun2(){cout << "Derive::fun2()" << endl;}
};

int main()
{
         Derive d;
         d.fun();
         //下面一句错误，故屏蔽掉
         //d.fun(1);error C2660: 'fun' : function does not take 1 parameters
         return 0;
}
例4
#include <iostream>
using namespace std;

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

class Derive :public Basic{
public:
         using Basic::fun;
         void fun(){cout << "Derive::fun()" << endl;}
         void fun2(){cout << "Derive::fun2()" << endl;}
};

int main()
{
         Derive d;
         d.fun();//正确
         d.fun(1);//正确
         return 0;
}
/*
输出结果

Derive::fun()
Base::fun(int i)
Press any key to continue
*/
例5
#include <iostream>
using namespace std;

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

class Derive :public Basic{
public:
         using Basic::fun;
         void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}
         void fun2(){cout << "Derive::fun2()" << endl;}
};

int main()
{
         Derive d;
         d.fun();//正确
         d.fun(1);//正确
         d.fun(1,2);//正确
         return 0;
}
/*
输出结果

Base::fun()
Base::fun(int i)
Derive::fun(int i,int j)
Press any key to continue
*/