重载、覆盖、多态与函数隐藏(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了。