重载、覆盖、多态与函数隐藏(2)

好了,我们先来一个小小的总结重载与覆盖两者之间的特征
重载overload的特征:
n          相同的范围(在同一个类中);
n          函数名相同参数不同;
n          virtual 关键字可有可无。

覆盖override是指派生类函数覆盖基类函数,覆盖的特征是:
n          不同的范围(分别位于派生类与基类);
n          函数名和参数都相同;
n          基类函数必须有virtual 关键字。(若没有virtual 关键字则称之为隐藏hide)

如果基类有某个函数的多个重载(overload)版本,而你在派生类中重写(override)了基类中的一个或多个函数版本,或是在派生类中重新添加了新的函数版本(函数名相同,参数不同),则所有基类的重载版本都被屏蔽,在这里我们称之为隐藏hide。所以,在一般情况下,你想在派生类中使用新的函数版本又想使用基类的函数版本时,你应该在派生类中重写基类中的所有重载版本。你若是不想重写基类的重载的函数版本,则你应该使用例4或例5方式,显式声明基类名字空间作用域。

事实上,C++编译器认为,相同函数名不同参数的函数之间根本没有什么关系,它们根本就是两个毫不相关的函数。只是 C++语言为了模拟现实世界,为了让程序员更直观的思维处理现实世界中的问题,才引入了重载和覆盖的概念。重载是在相同名字空间作用域下,而覆盖则是在不同的名字空间作用域下,比如基类和派生类即为两个不同的名字空间作用域。在继承过程中,若发生派生类与基类函数同名问题时,便会发生基类函数的隐藏。当然,这里讨论的情况是基类函数前面没有virtual 关键字。在有virtual 关键字关键字时的情形我们另做讨论。

继承类重写了基类的某一函数版本,以产生自己功能的接口。此时C++编绎器认为,你现在既然要使用派生类的自己重新改写的接口,那我基类的接口就不提供给你了(当然你可以用显式声明名字空间作用域的方法,见[C++基础]重载、覆盖、多态与函数隐藏(1))。而不会理会你基类的接口是有重载特性的。若是你要在派生类里继续保持重载的特性,那你就自己再给出接口重载的特性吧。所以在派生类里,只要函数名一样,基类的函数版本就会被无情地屏蔽。在编绎器中,屏蔽是通过名字空间作用域实现的。

所以,在派生类中要保持基类的函数重载版本,就应该重写所有基类的重载版本。重载只在当前类中有效,继承会失去函数重载的特性。也就是说,要把基类的重载函数放在继承的派生类里,就必须重写。

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,具体规则我们也来做一小结:
n          如果派生类的函数与基类的函数同名,但是参数不同。此时,若基类无virtual关键字,基类的函数将被隐藏。(注意别与重载混淆,虽然函数名相同参数不同应称之为重载,但这里不能理解为重载,因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏)
n          如果派生类的函数与基类的函数同名,但是参数不同。此时,若基类有virtual关键字,基类的函数将被隐式继承到派生类的vtable中。此时派生类 vtable中的函数指向基类版本的函数地址。同时这个新的函数版本添加到派生类中,作为派生类的重载版本。但在基类指针实现多态调用函数方法时,这个新的派生类函数版本将会被隐藏。
n          如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏。(注意别与覆盖混淆,这里理解为隐藏)。
n          如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数有virtual关键字。此时,基类的函数不会被“隐藏”。(在这里,你要理解为覆盖哦 ^_^)。

插曲:基类函数前没有virtual关键字时,我们要重写更为顺口些,在有virtual关键字时,我们叫覆盖更为合理些,戒此,我也希望大家能够更好的理解C++中一些微妙的东西。费话少说,我们举例说明吧。

例6
#include <iostream>
using namespace std;

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

class Derive : public Base{
public:
    void fun() { cout << "Derive::fun()" << endl; }//override
    void fun(int i) { cout << "Derive::fun(int i)" << endl; }//override
    void fun(int i,int j){ cout<< "Derive::fun(int i,int j)" <<endl;}//overload
};

int main()
{
  Base *pb  = new Derive();
  pb->fun();
  pb->fun(1);
  //下面一句错误,故屏蔽掉
  //pb->fun(1,2);virtual函数不能进行overload,error C2661: 'fun' : no overloaded function takes 2 parameters

  cout << endl;
  Derive *pd  = new Derive();
  pd->fun();
  pd->fun(1);
  pd->fun(1,2);//overload
  delete pb;
  delete pd;
  return 0;
}
/*
输出结果
Derive::fun()
Derive::fun(int i)
Derive::fun()
Derive::fun(int i)
Derive::fun(int i,int j)
Press any key to continue
*/

例7-1
#include <iostream>
using namespace std;

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

class Derive : public Base{};

int main()
{
         Base *pb = new Derive();
         pb->fun(1);//Base::fun(int i)
         delete pb;
         return 0;
}

例7-2
#include <iostream>
using namespace std;
 
class Base{
public:
         virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
};
 
class Derive : public Base{
public:
    void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }
};

int main()
{
         Base *pb = new Derive();
         pb->fun(1);//Base::fun(int i)
         pb->fun((double)0.01);//Base::fun(int i)
         delete pb;
         return 0;
}

例8-1
#include <iostream>
using namespace std;
 
class Base{
public:
         virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
};
 
class Derive : public Base{
public:
         void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }
};

int main()
{
         Base *pb = new Derive();
         pb->fun(1);//Derive::fun(int i)
         delete pb;
         return 0;
}

(篇幅所限,未完,待续)
coder_jack@126.com 日记写到200904012201

 

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/coder_jack/archive/2010/05/27/5629442.aspx

作者: coder_jack   发布时间: 2010-09-15