重载与覆盖的区别2

 

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

 

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

 

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

 

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

 

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，具体规则我们也来做一小结：

①         如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类无 virtual 关键字，基类的函数将被隐藏。 ( 注意别与重载混淆，虽然函数名相同参数不同应称之为重载，但这里不能理解为重载，因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏 )

②    如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类有 virtual 关键字，基类的函数将被隐式继承到派生类的 vtable 中 。此时派生类 vtable 中的函数指向基类版本的函数地址。 同时这个新的函数版本添加到派生类中，作为派生类的重载版本。但在基类指针实现多态调用函数方法时，这个新的派生类函数版本将会被隐藏。

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

④           如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数有 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;

}

例 8-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(int i){ cout <<"Derive::fun(int i)"<< endl; }

         void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }        

};

 

int main()

{

         Base *pb = new Derive();

         pb->fun(1);//Derive::fun(int i)

              pb->fun((double)0.01);//Derive::fun(int i)

         delete pb;

         return 0;

}

 

例 9

#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; }

              void fun(char c){ cout <<"Derive::fun(char c)"<< endl; }  

              void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }   

};

int main()

{

         Base *pb = new Derive();

         pb->fun(1);//Derive::fun(int i)

              pb->fun('a');//Derive::fun(int i)

              pb->fun((double)0.01);//Derive::fun(int i)

 

              Derive *pd =new Derive();

         pd->fun(1);//Derive::fun(int i)

         //overload

              pd->fun('a');//Derive::fun(char c)         

         //overload

              pd->fun(0.01);//Derive::fun(double d)         

 

         delete pb;

              delete pd;

         return 0;

}