?[C++基礎]重載、覆蓋、多態(tài)與函數(shù)隱藏
?
小結：
?
???????
重載
overload
是根據(jù)函數(shù)的參數(shù)列表來選擇要調用的函數(shù)版本，而多態(tài)是根據(jù)運行時對象的實際類型來選擇要調用的虛
virtual
函數(shù)版本，多態(tài)的實現(xiàn)是通過派生類對基類的虛
virtual
函數(shù)進行覆蓋
override
來實現(xiàn)的，若派生類沒有對基類的虛
virtual
函數(shù)進行覆蓋
override
的話，則派生類會自動繼承基類的虛
virtual
函數(shù)版本，此時無論基類指針指向的對象是基類型還是派生類型，都會調用基類版本的虛
virtual
函數(shù)；如果派生類對基類的虛
virtual
函數(shù)進行覆蓋
override
的話，則會在運行時根據(jù)對象的實際類型來選擇要調用的虛
virtual
函數(shù)版本，例如基類指針指向的對象類型為派生類型，則會調用派生類的虛
virtual
函數(shù)版本，從而實現(xiàn)多態(tài)。
?
???????
使用多態(tài)的本意是要我們在基類中聲明函數(shù)為
virtual
，并且是要在派生類中覆蓋
override
基類的虛
virtual
函數(shù)版本，注意，此時的函數(shù)原型與基類保持一致，即同名同參數(shù)類型；如果你在派生類中新添加函數(shù)版本，你不能通過基類指針動態(tài)調用派生類的新的函數(shù)版本，這個新的函數(shù)版本只作為派生類的一個重載版本。還是同一句話，重載只有在當前類中有效，不管你是在基類重載的，還是在派生類中重載的，兩者互不牽連。如果明白這一點的話，在例
6
、例
9
中，我們也會對其的輸出結果順利地理解。
?
???????
重載是靜態(tài)聯(lián)編的，多態(tài)是動態(tài)聯(lián)編的。進一步解釋，重載與指針實際指向的對象類型無關，多態(tài)與指針實際指向的對象類型相關。若基類的指針調用派生類的重載版本，
C++
編繹認為是非法的，
C++
編繹器只認為基類指針只能調用基類的重載版本，重載只在當前類的名字空間作用域內有效，繼承會失去重載的特性，當然，若此時的基類指針調用的是一個虛
virtual
函數(shù)，那么它還會進行動態(tài)選擇基類的虛
virtual
函數(shù)版本還是派生類的虛
virtual
函數(shù)版本來進行具體的操作，這是通過基類指針實際指向的對象類型來做決定的，所以說重載與指針實際指向的對象類型無關，多態(tài)與指針實際指向的對象類型相關。
?
?
???
最后闡明一點，虛
virtual
函數(shù)同樣可以進行重載，但是重載只能是在當前自己名字空間作用域內有效
(
請再次參考例
6)。
本文來源:http://blog.csdn.net/callzjy/archive/2004/01/04/20044.aspx
續(xù):
重載與覆蓋
成員函數(shù)被重載的特征：
（1）相同的范圍（在同一個類中）；
（2）函數(shù)名字相同；
（3）參數(shù)不同；
（4）virtual關鍵字可有可無。
覆蓋是指派生類函數(shù)覆蓋基類函數(shù)，特征是：
（1）不同的范圍（分別位于派生類與基類）；
（2）函數(shù)名字相同；
（3）參數(shù)相同；
（4）基類函數(shù)必須有virtual關鍵字。
“隱藏”是指派生類的函數(shù)屏蔽了與其同名的基類函數(shù)，
規(guī)則如下：
（1）如果派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)不同。
???? 此時，不論有無virtual關鍵字，基類的函數(shù)將被隱藏（注意別與重載混淆）。
（2）如果派生類的函數(shù)與基類的函數(shù)同名，并且參數(shù)也相同，但是基類函數(shù)沒有virtual關鍵字。
???? 此時，基類的函數(shù)被隱藏（注意別與覆蓋混淆）。
如下示例程序中：
（1）函數(shù)Derived::f(float)覆蓋了Base::f(float)。
（2）函數(shù)Derived::g(int)隱藏了Base::g(float)，而不是重載。
（3）函數(shù)Derived::h(float)隱藏了Base::h(float)，而不是覆蓋。
#include<iostream.h>
class Base{
public:
virtual void f(floatx){cout<<"Base::f(float)"<<x<<endl;}
??????? void g(floatx){cout<<"Base::g(float)"<<x<<endl;
??????? void h(floatx){cout<<"Base::h(float)"<<x<<endl;}
};
class Derived:publicBase{
public:
virtual void f(floatx){cout<<"Derived::f(float)"<<x<<endl;}
??????? void g(intx){cout<<"Derived::g(int)"<<x<<endl;}
??????? void h(floatx){cout<<"Derived::h(float)"<<x<<endl;}
};
void main(void){
? 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
?
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=283879