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

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

例7-1和例8-1很好理解，我把这两个例子放在这里，是让大家作一个比较摆了，也是为了帮助大家更好的理解：
n    例7-1中，派生类没有覆盖基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是基类的虚函数地址。
n   例8-1中，派生类覆盖了基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是派生类自己的重写的虚函数地址。
在例7-2和8-2 看起来有点怪怪，其实，你按照上面的原则对比一下，答案也是明朗的：
n     例7-2中，我们为派生类重载了一个函数版本：void fun(double d)  其实，这只是一个障眼法。我们具体来分析一下，基类共有几个函数，派生类共有几个函数：

 

类型	基类	派生类
Vtable 部分	void fun(int i )	指向基类版的 虚函数 void fun(int i )
静态部分		void fun(double d )

 

我们再来分析一下以下三句代码
Base *pb = new Derive();
pb->fun(1);//Base::fun(int i)
pb->fun((double)0.01);//Base::fun(int i)

这第一句是关键，基类指针指向派生类的对象，我们知道这是多态调用；接下来第二句，运行时基类指针根据运行时对象的类型，发现是派 生类对象，所以首先到派生类的vtable中去查找派生类的虚函数版本，发现派生类没有覆盖基类的虚函数，派生类的vtable只是作了一个指向基类虚函 数地址的一个指向，所以理所当然地去调用基类版本的虚函数。最后一句，程序运行仍然埋头去找派生类的vtable，发现根本没有这个版本的虚函数，只好回 头调用自己的仅有一个虚函数。

这里还值得一提的是：如果此时基类有多个虚函数，此时程序编绎时会提示”调用不明确”。示例如下
#include <iostream>
using namespace std;

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

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

int main()
{
         Base *pb = new Derive();
          pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function
         delete pb;
         return 0;
}

好了，我们再 来分析一下例8-2。
n   例8-2中，我们也为派生类重载了一个函数版本：void fun(double d)  ，同时覆盖了基类的虚函数，我们再来具体来分析一下，基类共有几个函数，派生类共有几个函数：

 

类型	基类	派生类
Vtable 部分	void fun(int i )	void fun(int i )
静态部分		void fun(double d )

 

从表中我们可以看到，派生类的 vtable中函数指针指向的是自己的重写的虚函数地址。
我们再来分析一下以下三句代码
Base *pb = new Derive();
pb->fun(1);//Derive::fun(int i)
pb->fun((double)0.01);//Derive::fun(int i)
第一句不必多说了，第二句，理所当然调用派生类的虚函数版本，第三句，嘿，感觉又怪怪的，其实呀，C++程序很笨的了，在运行时，埋头闯进 派生类的vtable表中，只眼一看，靠，竞然没有想要的版本，真是想不通，基类指针为什么不四处转转再找找呢?呵呵，原来是眼力有限，基类年纪这么老 了，想必肯定是老花了，它那双眼睛看得到的仅是自己的非Vtable部分(即静态部分)和自己要管理的Vtable部分，派生类的void fun(double d)那么远，看不到呀!再说了，派生类什么都要管，难道派生类没有自己的一点权力吗?哎，不吵了，各自管自己的吧^_^
 
唉! 你是不是要叹气了，基类指针能进行多态调用，但是始终不能进行派生类的重载调用啊(参考例6)~~~

再来看看例9，
本例的效果同 例6，异曲同工。想必你理解了上面的这些例子后，这个也是小Kiss了。

 

小结：
        重载overload是根据函数的参数列表来选择要调用的函数版本，而多态是根据运行时对象的实际类型来选择要调用的虚virtual函数版本，多态的实 现是通过派生类对基类的虚virtual函数进行覆盖override来实现的，若派生类没有对基类的虚virtual函数进行覆盖override的 话，则派生类会自动继承基类的虚virtual函数版本，此时无论基类指针指向的对象是基类型还是派生类型，都会调用基类版本的虚virtual函数；如 果派生类对基类的虚virtual函数进行覆盖override的话，则会在运行时根据对象的实际类型来选择要调用的虚virtual函数版本，例如基类 指针指向的对象类型为派生类型，则会调用派生类的虚virtual函数版本，从而实现多态。
        使用多态的本意是要我们在基类中声明函数为virtual，并且是要在派生类中覆盖override基类的虚virtual函数版本，注意，此时的函数原 型与基类保持一致，即同名同参数类型；如果你在派生类中新添加函数版本，你不能通过基类指针动态调用派生类的新的函数版本，这个新的函数版本只作为派生类 的一个重载版本。还是同一句话，重载只有在当前类中有效，不管你是在基类重载的，还是在派生类中重载的，两者互不牵连。如果明白这一点的话，在例6、例9 中，我们也会对其的输出结果顺利地理解。
        重载是静态联编的，多态是动态联编的。进一步解释，重载与指针实际指向的对象类型无关，多态与指针实际指向的对象类型相关。若基类的指针调用派生类的重载 版本，C++编绎认为是非法的，C++编绎器只认为基类指针只能调用基类的重载版本，重载只在当前类的名字空间作用域内有效，继承会失去重载的特性，当 然，若此时的基类指针调用的是一个虚virtual函数，那么它还会进行动态选择基类的虚virtual函数版本还是派生类的虚virtual函数版本来 进行具体的操作，这是通过基类指针实际指向的对象类型来做决定的，所以说重载与指针实际指向的对象类型无关，多态与指针实际指向的对象类型相关。
    最后阐明一点，虚virtual函数同样可以进行重载，但是重载只能是在当前自己名字空间作用域内有效(请再次参考例6)。

重载与覆盖
成 员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual关 键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3） 参数相同；
（4）基类函数必须有virtual关键字。

“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，
规则如下：
（1） 如果派生类的函数与基类的函数同名，但是参数不同。
此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2） 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。
此时，基类的函数被隐藏（注意别与覆盖混淆）。

如 下示例程序中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数 Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了 Base::h(float)，而不是覆盖。

#include<iostream.h>

class Base{
public:
    virtual void f(float x){cout<<"Base::f(float)"<<x<<endl;}
    void g(float x){cout<<"Base::g(float)"<<x<<endl;
    void h(float x){cout<<"Base::h(float)"<<x<<endl;}
    };
   
    class Derived:public Base{
    public:
        virtual void f(float x){cout<<"Derived::f(float)"<<x<<endl;}
        void g(int x){cout<<"Derived::g(int)"<<x<<endl;}
        void h(float x){cout<<"Derived::h(float)"<<x<<endl;}
    };
void main()
{
        Derived d;
        Base *pb=&d;
        Derived *pd=&d;
       
        //Good:behavior depends solely on type of the object
        pb->f(3.14f);     //Derived::f(float)3.14
        pd->f(3.14f);     //Derived::f(float)3.14
       
        //Bad:behavior depends on type of the pointer
        pb->g(3.14f);     //Base::g(float)3.14
        pd->g(3.14f);     //Derived::g(int)3(surprise!)
       
        //Bad:behavior depends on type of the pointer
        pb->h(3.14f);     //Base::h(float)3.14(surprise!)
        pd->h(3.14f);     //Derived::h(float)3.14
}

（全文完）
[email protected] 日记写到200904012216