重載(overload):
必須在一個域中,函數名稱相同但是函數參數不同,重載的作用就是同一個函數有不同的行爲,因此不是在一個域中的函數是無法構成重載的,這個是重載的重要特徵
覆蓋(override):
覆蓋指的是派生類的虛擬函數覆蓋了基類的同名且參數相同的函數,既然是和虛擬函數掛鉤,說明了這個是一個多態支持的特性,所謂的覆蓋指的是用基類對象的指針或者引用時訪問虛擬函數的時候會根據實際的類型決定所調用的函數,因此此時派生類的成員函數可以"覆蓋"掉基類的成員函數.
注意唯有同名且參數相同還有帶有virtual關鍵字並且分別在派生類和基類的函數才能構成虛擬函數,這個也是派生類的重要特徵.
而且,由於是和多態掛鉤的,所以只有在使用類對象指針或者引用的時候才能使用上.
總之一句話:覆蓋函數都是虛函數,反之不然~~
隱藏(hide):
指的是派生類的成員函數隱藏了基類函數的成員函數.隱藏一詞可以這麼理解:在調用一個類的成員函數的時候,編譯器會沿着類的繼承鏈逐級的向上查找函數的定義,如果找到了那麼就停止查找了,所以如果一個派生類和一個基類都有同一個同名(暫且不論參數是否相同)的函數,而編譯器最終選擇了在派生類中的函數,那麼我們就說這個派生類的成員函數"隱藏"了基類的成員函數,也就是說它阻止了編譯器繼續向上查找函數的定義....
回到隱藏的定義中,前面已經說了有virtual關鍵字並且分別位於派生類和基類的同名,同參數函數構成覆蓋的關係,因此隱藏的關係只有如下的可能:
1)必須分別位於派生類和基類中
2)必須同名
3)參數不同的時候本身已經不構成覆蓋關係了,所以此時是否是virtual函數已經不重要了
當參數相同的時候就要看時候有virtual關鍵字了,有的話就是覆蓋關係,沒有的時候就是隱藏關係了
上面的解說大體把三者的區別給說清楚了,但是還有一些疑惑的地方,以下以代碼例子說明.
很多人分辨不清隱藏和覆蓋的區別,因爲他們都是發生在基類和派生類之中的.但是它們之間最爲重要的區別就是:
覆蓋的函數是多態的,是存在於vtbl之中的函數才能構成"覆蓋"的關係,而隱藏的函數都是一般的函數,不支持多態,在編譯階段就已經確定下來了.
1 class Base
2 {
3 public :
4 virtual void f( float x) {cout << " Base::f(folat) " << x << endl;}
5 void g( float x) {cout << " Base::g(float) " << x << endl;}
6 } ;
7
8 class Derived: public Base
9 {
10 public :
11 virtual void f( float x) {cout << " Derived::f(float) " << x << endl;}
12 void g( int x) {cout << " Deriver::g(int) " << x << endl;}
13 } ;
14
15 int main()
16 {
17 Derived d;
18 Base * pb =& d;
19 Derived * pd =& d;
20 pb -> f( 3.14f );
21 pd -> f( 3.14f );
22 pb -> g( 3.14f ); // 輸出結果：Base::g(float)3.14
23 pd -> g( 3.14f ); // 輸出結果：Dervied::g(int)3
24 return 0 ;
25 }
26
在調用f函數的時候,派生類Derived的f函數覆蓋了基類Base的f函數,而派生類Derived的g函數隱藏了基類Base的g函數.2 {
3 public :
4 virtual void f( float x) {cout << " Base::f(folat) " << x << endl;}
5 void g( float x) {cout << " Base::g(float) " << x << endl;}
6 } ;
7
8 class Derived: public Base
9 {
10 public :
11 virtual void f( float x) {cout << " Derived::f(float) " << x << endl;}
12 void g( int x) {cout << " Deriver::g(int) " << x << endl;}
13 } ;
14
15 int main()
16 {
17 Derived d;
18 Base * pb =& d;
19 Derived * pd =& d;
20 pb -> f( 3.14f );
21 pd -> f( 3.14f );
22 pb -> g( 3.14f ); // 輸出結果：Base::g(float)3.14
23 pd -> g( 3.14f ); // 輸出結果：Dervied::g(int)3
24 return 0 ;
25 }
26
爲什麼?理由很簡單,f函數是virtual函數,但是g函數不是.我們可以把Base類和Derived類看成這樣的一個struct:
1 struct Base
2 {
3 void (*g)(float); // Base類型的函數指針,不可變
4 struct VTABLE *__vptr; // 虛擬函數指針數組,可變
5 };
6
7 void __Baseg(float)
8 {
9 cout<<"Base::g(folat)"<<
10 }
11
12 struct Derived
13 {
14 void (*g)(float); // Derived類型的函數指針,不可變
15 struct VTABLE *__vptr; // 虛擬函數指針數組,可變
16 };
17
18 void __Derivedg(float)
19 {
20 cout<<"Deriver::g(int)"<<
21 }
22
23 struct VTABLE
24 {
25 void (*f)(float); // 函數指針
26 };
27
28 void __Basef(float)
29 {
30 cout<<"Base::f(folat)"<<
31 }
32
33 void __Derivedf(float)
34 {
35 cout<<"Deriver::f(int)"<<
36 }
37
2 {
3 void (*g)(float); // Base類型的函數指針,不可變
4 struct VTABLE *__vptr; // 虛擬函數指針數組,可變
5 };
6
7 void __Baseg(float)
8 {
9 cout<<"Base::g(folat)"<<
10 }
11
12 struct Derived
13 {
14 void (*g)(float); // Derived類型的函數指針,不可變
15 struct VTABLE *__vptr; // 虛擬函數指針數組,可變
16 };
17
18 void __Derivedg(float)
19 {
20 cout<<"Deriver::g(int)"<<
21 }
22
23 struct VTABLE
24 {
25 void (*f)(float); // 函數指針
26 };
27
28 void __Basef(float)
29 {
30 cout<<"Base::f(folat)"<<
31 }
32
33 void __Derivedf(float)
34 {
35 cout<<"Deriver::f(int)"<<
36 }
37
在程序編譯的時候,函數指針f就已經是確定的了,但是__vptr根據不同的而有分別,而這個變化是運行期動態決定的.
也就是說:f的地址不可變,__vptr可變.
回到上面的例子中,Base *pb=&d;的時候只是用Derived類對象d的__vptr修改了Base類pb的__vptr指針,但是當Base類成員建立的
時候f函數指針就是不能改變的.
當函數被聲明爲virtual的時候,就激活了多態機制,程序在運行的時候會根據類型的實際類型到VTABLE中查找函數指針,因此對函數g的調用就是這樣子的:
pb->__vptr->g();
而對f的調用就是一般的類成員函數指針的調用了:pb->f(),因爲這個類型在程序編譯的時候已經確認了,所以在程序運行的時候是不能發生改變的.
綜上,可以把
Derived d;
Base *pb=&d;
的過程分解爲:
d.g = __Derivedg;
d.__vptr->f = __Derivedf;
pb->g = __Baseg; // 這裏根據指針的真正類型確定函數指針
pb->__vptr = d.__vptr; // 這裏只是簡單的指針賦值,因此訪問到的就是Derived的函數了
最後在調用:
pb->f(3.14f);
pb->g(3.14f);
實際上是:
pb->__vptr->__Derivedf(3.14f);
__Baseg(3.14f);
這麼寫就明白最後在調用的時候爲什麼會用那樣的結果了,可以看出多了一個__vptr這個間接層實現了所謂的"動態綁定".
最後,需要說明的一點是:實際上在c++中,非static和非virtual的函數指針並不會在一個class中保存它的函數指針,上面把函數g的指針寫在struct裏面只是爲了方便說明這樣的問題:在編譯階段這個函數就已經是確定的不可改變的了.特此說明一下.
虛函數與純虛函數
虛函數是指一個類中你希望重載的成員函數，當你用一個基類指針或引用指向一個繼承類對象的時候，你調用一個虛函數，實際調用的是繼承類的版本。
定義一個函數爲虛函數，不代表函數爲不被實現的函數，定義它爲虛函數是爲了允許用基類的指針來調用子類的這個函數
定義一個函數爲純虛函數，才代表函數沒有被實現，定義他是爲了實現一個接口，起到一個規範的作用，規範繼承這個類的程序員必須實現這個函數。
有純虛函數的類是抽象類，不能生成對象，只能派生。他派生的類的純虛函數沒有被改寫，那麼，它的派生類還是個抽象類。
1.爲了安全.因爲避免任何需要明確但是因爲不小心而導致的未知的結果. 提醒子類去做應做的實現.
2.爲了效率,不是程序執行的效率,而是爲了編碼的效率.