c++之虛函數和基類指針

　　1. 基類指針雖然獲取派生類對象地址，卻只能訪問派生類從基類繼承的成員

 1 #include <iostream>
 2 using namespace std;
 3 
 4 //經過基類指針只能訪問從基類繼承的成員
 5 class A
 6 {
 7 public:
 8     A(char x)
 9     {
10         this->x = x;
11     }
12     //void virtual who()    //基類定義虛函數，則派生類的重定義版本默認爲虛函數
13     void who()    //除非定義虛函數，不然基類指針沒法訪問派生類的非繼承的成員
14     {
15         cout << "A class" << x << endl;
16     }
17 protected:
18     char x;
19 };
20 
21 class B:public A
22 {
23 public:
24     B(char x,char y):A(x)
25     {
26         this->y = y;
27     }
28     void who()
29     {
30         cout<< "B class" << x << "," << y<< endl;
31     }
32 protected:
33     char y;
34 };
35 class C:public B
36 {
37 public:
38     C(char x,char y,char z):B(x,y)
39     {
40         this->z = z;
41     }
42     void who()
43     {
44         cout<< "C class " << x << "," << y << "," << z << endl;
45     }
46 protected:
47     char z;
48 };
49 
50 void main()
51 {
52     A a('A'); 
53     B b('T','O');
54     C c('E','N','D');
55     //定義基類指針
56     A* aa;
57     aa = &a;
58     aa->who();
59     aa = &b;
60     //只能調用從基類繼承的函數
61     aa->who();
62     aa = & c;
63     //只能調用從基類繼承的函數
64     aa->who();
65     //經過對象調用自身的成員函數
66     b.who();
67     //基類指針作類型轉換，調用轉換後的類型的類成員函數
68     ((C*)aa)->who();
69 }

2.虛函數和基類指針

注意：

　　一個虛函數，在派生類層界面相同的重載函數都保持虛特性

　　虛函數必須是類的成員函數

　　不能將友元說明爲虛函數，但虛函數能夠是另外一個類的友元

　　析構函數能夠是虛函數，但構造函數不能是虛函數

3.虛函數的重載特性

 

　　在派生類中重載基類的虛函數要求函數名、返回類型、參數個數、

 

　　參數類型和順序徹底相同

 

　　若是僅僅返回類型不一樣，C++認爲是錯誤重載

 

　　若是函數原型不一樣，僅函數名相同，丟失虛特性 

 1 例：
 2 class  base
 3 { public : 
 4       virtual  void  vf1 ( ) ;
 5       virtual  void  vf2 ( ) ;
 6       virtual  void  vf3 ( ) ;
 7       void  f ( ) ;
 8  } ;
 9 class  derived : public  base
10 { public : 
11       void  vf1 ( ) ;        // 虛函數
12       void  vf2 ( int ) ;    // 重載，參數不一樣，虛特性丟失
13       char  vf3 ( ) ;        // error，僅返回類型不一樣
14       void f ( ) ;        // 非虛函數重載
15  } ;
16 
17 void  g ( ) 
18 { derived   d ;
19    base  * bp = & d ;        // 基類指針指向派生類對象
20    bp -> vf1 ( ) ;            // 調用 deriver :: vf1 ( )
21    bp -> vf2 ( ) ;            // 調用 base :: vf2 ( )
22    bp -> f ( ) ;            // 調用 base :: f ( )
23 } ;